100% found this document useful (1 vote)
57 views

The Definitive Guide to AdonisJs: Building Node.js Applications with JavaScript Christopher Pitt All Chapters Instant Download

Pitt

Uploaded by

haithghiasam
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
100% found this document useful (1 vote)
57 views

The Definitive Guide to AdonisJs: Building Node.js Applications with JavaScript Christopher Pitt All Chapters Instant Download

Pitt

Uploaded by

haithghiasam
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 55

Download the Full Version of textbook for Fast Typing at textbookfull.

com

The Definitive Guide to AdonisJs: Building Node.js


Applications with JavaScript Christopher Pitt

https://textbookfull.com/product/the-definitive-guide-to-
adonisjs-building-node-js-applications-with-javascript-
christopher-pitt/

OR CLICK BUTTON

DOWNLOAD NOW

Download More textbook Instantly Today - Get Yours Now at textbookfull.com


Recommended digital products (PDF, EPUB, MOBI) that
you can download immediately if you are interested.

The Definitive Guide to JSF in Java EE 8: Building Web


Applications with JavaServer Faces Bauke Scholtz

https://textbookfull.com/product/the-definitive-guide-to-jsf-in-java-
ee-8-building-web-applications-with-javaserver-faces-bauke-scholtz/

textboxfull.com

Ultimate Node.js for Cross-Platform App Development: Learn


to Build Robust, Scalable, and Performant Server-Side
JavaScript Applications with Node.js (English Edition)
Kumar
https://textbookfull.com/product/ultimate-node-js-for-cross-platform-
app-development-learn-to-build-robust-scalable-and-performant-server-
side-javascript-applications-with-node-js-english-edition-kumar/
textboxfull.com

JavaScript The Definitive Guide 7th Edition David Flanagan

https://textbookfull.com/product/javascript-the-definitive-guide-7th-
edition-david-flanagan/

textboxfull.com

Building web and mobile ArcGIS Server applications with


JavaScript Lewin

https://textbookfull.com/product/building-web-and-mobile-arcgis-
server-applications-with-javascript-lewin/

textboxfull.com
Guide to Scientific Computing in C Pitt-Francis

https://textbookfull.com/product/guide-to-scientific-computing-in-c-
pitt-francis/

textboxfull.com

Understanding ECMAScript 6 The definitive guide for


Javascript developers 1st Edition Nicholas C. Zakas

https://textbookfull.com/product/understanding-ecmascript-6-the-
definitive-guide-for-javascript-developers-1st-edition-nicholas-c-
zakas/
textboxfull.com

Practical Bot Development: Designing and Building Bots


with Node.js and Microsoft Bot Framework Szymon Rozga

https://textbookfull.com/product/practical-bot-development-designing-
and-building-bots-with-node-js-and-microsoft-bot-framework-szymon-
rozga/
textboxfull.com

Pentesting Azure Applications The Definitive Guide to


Testing and Securing Deployments 1st Edition Matt Burrough

https://textbookfull.com/product/pentesting-azure-applications-the-
definitive-guide-to-testing-and-securing-deployments-1st-edition-matt-
burrough/
textboxfull.com

Guide to Scientific Computing in C 2nd Edition Joe Pitt-


Francis

https://textbookfull.com/product/guide-to-scientific-computing-
in-c-2nd-edition-joe-pitt-francis/

textboxfull.com
The Definitive
Guide to AdonisJs
Building Node.js Applications with JavaScript

Christopher Pitt
The Definitive Guide to
AdonisJs
Building Node.js Applications
with JavaScript

Christopher Pitt
The Definitive Guide to AdonisJs: Building Node.js Applications with JavaScript
Christopher Pitt
Cape Town, Western Cape, South Africa

ISBN-13 (pbk): 978-1-4842-3389-4 ISBN-13 (electronic): 978-1-4842-3390-0


https://doi.org/10.1007/978-1-4842-3390-0
Library of Congress Control Number: 2018937100

Copyright © 2018 by Christopher Pitt


This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the
material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation,
broadcasting, reproduction on microfilms or in any other physical way, and transmission or information
storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now
known or hereafter developed.
Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol with
every occurrence of a trademarked name, logo, or image, we use the names, logos, and images only in an
editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the
trademark.
The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not
identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to
proprietary rights.
While the advice and information in this book are believed to be true and accurate at the date of publication,
neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or
omissions that may be made. The publisher makes no warranty, express or implied, with respect to the
material contained herein.
Managing Director, Apress Media LLC: Welmoed Spahr
Acquisitions Editor: Steve Anglin
Development Editor: Matthew Moodie
Coordinating Editor: Mark Powers
Cover designed by eStudioCalamar
Cover image designed by Freepik (www.freepik.com)
Distributed to the book trade worldwide by Springer Science+Business Media New York,
233 Spring Street, 6th Floor, New York, NY 10013. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail
[email protected], or visit www.springeronline.com. Apress Media, LLC is a California LLC and
the sole member (owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM
Finance Inc is a Delaware corporation.
For information on translations, please e-mail [email protected]; for reprint, paperback, or audio rights,
please email [email protected].
Apress titles may be purchased in bulk for academic, corporate, or promotional use. eBook versions and
licenses are also available for most titles. For more information, reference our Print and eBook Bulk Sales
web page at www.apress.com/bulk-sales.
Any source code or other supplementary material referenced by the author in this book is available to
readers on GitHub via the book’s product page, located at www.apress.com/9781484233894. For more
detailed information, please visit www.apress.com/source-code.
Printed on acid-free paper
Table of Contents
About the Author����������������������������������������������������������������������������������������������������� ix

Acknowledgments��������������������������������������������������������������������������������������������������� xi
Introduction����������������������������������������������������������������������������������������������������������� xiii

Chapter 1: Getting Started���������������������������������������������������������������������������������������� 1


Installing Node.js��������������������������������������������������������������������������������������������������������������������������� 1
Installing the AdonisJs Command-Line Tool��������������������������������������������������������������������������������� 3
Creating a New Application����������������������������������������������������������������������������������������������������������� 3
Serving the Application����������������������������������������������������������������������������������������������������������������� 4
Exploring the Code������������������������������������������������������������������������������������������������������������������������ 5
Summary������������������������������������������������������������������������������������������������������������������������������������ 10

Chapter 2: Routing�������������������������������������������������������������������������������������������������� 11
What Are Routes?������������������������������������������������������������������������������������������������������������������������ 11
Planning Routes�������������������������������������������������������������������������������������������������������������������������� 12
Defining Routes��������������������������������������������������������������������������������������������������������������������������� 14
Testing Routes���������������������������������������������������������������������������������������������������������������������������� 15
Defining Route Parameters��������������������������������������������������������������������������������������������������������� 20
Summary������������������������������������������������������������������������������������������������������������������������������������ 26

Chapter 3: Views���������������������������������������������������������������������������������������������������� 27
Creating Views���������������������������������������������������������������������������������������������������������������������������� 27
Registering the View Provider����������������������������������������������������������������������������������������������� 28
Creating Layouts������������������������������������������������������������������������������������������������������������������������� 29
Learning Template Syntax����������������������������������������������������������������������������������������������������������� 34
Interpolation�������������������������������������������������������������������������������������������������������������������������� 35

iii
Table of Contents

Conditionals��������������������������������������������������������������������������������������������������������������������������� 36
Loops������������������������������������������������������������������������������������������������������������������������������������� 37
Partials���������������������������������������������������������������������������������������������������������������������������������� 38
Yield��������������������������������������������������������������������������������������������������������������������������������������� 38
Functions������������������������������������������������������������������������������������������������������������������������������� 39
Summary������������������������������������������������������������������������������������������������������������������������������������ 40

Chapter 4: Requests����������������������������������������������������������������������������������������������� 41
Updating Tests����������������������������������������������������������������������������������������������������������������������������� 41
Understanding Requests������������������������������������������������������������������������������������������������������������� 47
Getting Parameters���������������������������������������������������������������������������������������������������������������� 49
Getting Headers and Cookies������������������������������������������������������������������������������������������������ 50
Getting “accepts” and “language”���������������������������������������������������������������������������������������� 50
Finding Out More������������������������������������������������������������������������������������������������������������������� 51
Responding to POST, PUT, PATCH, and DELETE���������������������������������������������������������������������� 51
Summary������������������������������������������������������������������������������������������������������������������������������� 59

Chapter 5: Responses��������������������������������������������������������������������������������������������� 61
Sending Simple Responses�������������������������������������������������������������������������������������������������������� 61
Sending JSON Responses����������������������������������������������������������������������������������������������������������� 62
Working with Cookies����������������������������������������������������������������������������������������������������������������� 64
Redirecting Users������������������������������������������������������������������������������������������������������������������������ 64
Responding with Attachments���������������������������������������������������������������������������������������������������� 66
Extending with Macros��������������������������������������������������������������������������������������������������������������� 66
Summary������������������������������������������������������������������������������������������������������������������������������������ 70

Chapter 6: Generators��������������������������������������������������������������������������������������������� 71
Arrays: Where It All Began����������������������������������������������������������������������������������������������������������� 71
Then Came Iterators�������������������������������������������������������������������������������������������������������������������� 72
Generators���������������������������������������������������������������������������������������������������������������������������������� 75
Cooperative Multitasking������������������������������������������������������������������������������������������������������������ 76
Summary������������������������������������������������������������������������������������������������������������������������������������ 79

iv
Table of Contents

Chapter 7: Promises����������������������������������������������������������������������������������������������� 81
Reacting to Events���������������������������������������������������������������������������������������������������������������������� 81
Entering Callback Hell����������������������������������������������������������������������������������������������������������������� 82
Understanding Promises������������������������������������������������������������������������������������������������������������� 83
Using Promises with Coroutines������������������������������������������������������������������������������������������������� 84
Making Promises������������������������������������������������������������������������������������������������������������������������ 86
Bringing It Back to AdonisJs������������������������������������������������������������������������������������������������������� 88
Summary������������������������������������������������������������������������������������������������������������������������������������ 89

Chapter 8: Controllers and Middleware������������������������������������������������������������������ 91


Making Controllers���������������������������������������������������������������������������������������������������������������������� 91
Reusing Code������������������������������������������������������������������������������������������������������������������������������ 96
Using Middleware����������������������������������������������������������������������������������������������������������������������� 97
Summary���������������������������������������������������������������������������������������������������������������������������������� 101

Chapter 9: Databases������������������������������������������������������������������������������������������� 103


Installing Lucid�������������������������������������������������������������������������������������������������������������������������� 103
Making Migrations�������������������������������������������������������������������������������������������������������������������� 107
Seeding the Database��������������������������������������������������������������������������������������������������������������� 111
Working with Routes and the Database������������������������������������������������������������������������������������ 115
Showing Products��������������������������������������������������������������������������������������������������������������������� 116
Making Models�������������������������������������������������������������������������������������������������������������������������� 118
Registering Customers�������������������������������������������������������������������������������������������������������������� 121
Authenticating Customers��������������������������������������������������������������������������������������������������������� 125
Summary���������������������������������������������������������������������������������������������������������������������������������� 127

Chapter 10: Validation and Errors������������������������������������������������������������������������ 129


Installing Validation������������������������������������������������������������������������������������������������������������������� 129
Reusing Validation��������������������������������������������������������������������������������������������������������������������� 133
Displaying Custom Error Pages������������������������������������������������������������������������������������������������� 140
Creating Custom Exceptions����������������������������������������������������������������������������������������������������� 144
Summary���������������������������������������������������������������������������������������������������������������������������������� 146

v
Table of Contents

Chapter 11: Sessions�������������������������������������������������������������������������������������������� 147


Making the Dashboard�������������������������������������������������������������������������������������������������������������� 147
Creating the Customer Session������������������������������������������������������������������������������������������������� 154
Logging Customers Out������������������������������������������������������������������������������������������������������������� 158
Summary���������������������������������������������������������������������������������������������������������������������������������� 161

Chapter 12: Security��������������������������������������������������������������������������������������������� 163


Recap���������������������������������������������������������������������������������������������������������������������������������������� 163
Creating More Middleware�������������������������������������������������������������������������������������������������������� 164
Securing Forms������������������������������������������������������������������������������������������������������������������������� 168
Encrypting Values��������������������������������������������������������������������������������������������������������������������� 171
Summary���������������������������������������������������������������������������������������������������������������������������������� 172

Chapter 13: Front-End Tools��������������������������������������������������������������������������������� 173


Installing Mix����������������������������������������������������������������������������������������������������������������������������� 173
Installing Bootstrap (Sass)�������������������������������������������������������������������������������������������������������� 177
Installing React������������������������������������������������������������������������������������������������������������������������� 179
Summary���������������������������������������������������������������������������������������������������������������������������������� 182

Chapter 14: WebSockets��������������������������������������������������������������������������������������� 183


Installing Socket.io�������������������������������������������������������������������������������������������������������������������� 183
Building a React Shopping Cart������������������������������������������������������������������������������������������������ 189
Connecting the UI���������������������������������������������������������������������������������������������������������������������� 197
Creating Orders������������������������������������������������������������������������������������������������������������������������� 201
Summary���������������������������������������������������������������������������������������������������������������������������������� 205

Chapter 15: Deployment�������������������������������������������������������������������������������������� 207


Setting Up DigitalOcean������������������������������������������������������������������������������������������������������������ 208
Setting Up Forge����������������������������������������������������������������������������������������������������������������������� 209
Getting a Domain���������������������������������������������������������������������������������������������������������������������� 211
Adding the Domain Name in Forge������������������������������������������������������������������������������������������� 213
Setting Up DNS Servers������������������������������������������������������������������������������������������������������������ 215
Adding a Server Daemon���������������������������������������������������������������������������������������������������������� 216

vi
Table of Contents

Serving on Port 80�������������������������������������������������������������������������������������������������������������������� 220


Setting Up an SSL Certificate���������������������������������������������������������������������������������������������������� 221
Summary���������������������������������������������������������������������������������������������������������������������������������� 222

Chapter 16: Finishing Touches����������������������������������������������������������������������������� 223


Sending E-mail�������������������������������������������������������������������������������������������������������������������������� 223
Connecting to Stripe����������������������������������������������������������������������������������������������������������������� 230
Enabling CORS Requests���������������������������������������������������������������������������������������������������������� 238
Summary���������������������������������������������������������������������������������������������������������������������������������� 243

Index��������������������������������������������������������������������������������������������������������������������� 245

vii
About the Author
Christopher Pitt is a developer and writer working at Over. He usually works on
application architecture, though sometimes you’ll find him building compilers or robots.
He is also the author of several web development books and is a contributor on various
open source projects such as AdonisJs.

ix
Acknowledgments
Many people helped to make this book a reality. I’d like to thank them, in no
particular order.
Harminder and the rest of the core team have written some beautiful software.
I am continually amazed by how beautiful AdonisJs code can look. I enjoy JavaScript,
and it seems particularly suited to a framework like this. Harminder also gave insightful
technical feedback for this book.
Taylor began a wonder with Laravel. It’s clear that much of AdonisJs is inspired by
Laravel, and with good reason. Laravel kept me engaged in PHP, and AdonisJs will keep
me engaged in server-side JavaScript.
Mark, the coordinating editor, was fantastic to work with. He never got in the way
and was always helpful. That’s uncommon in his line of work. Matt, the development
editor, was similarly helpful and let me set the vision for this project, unencumbered.
These folks are a credit to Apress.
Matt, the writer, is an inspiration to me. He wrote what I consider to be the best
Laravel book on the market. Throughout this book, I sought to emulate his wisdom and
skill.
Bruno, Christian, and Wayne are good friends and supporters of my work. I miss
writing for Bruno. I miss having coffee with Christian. I will miss taking walks with
Wayne.
Liz, my love, has given me space and coffee in abundance. She is the inspiration
for the sample application, and though she finds me altogether strange, she loves me
effortlessly.

xi
Introduction
This book is designed to teach you how to use AdonisJs. To get the most out of it, you
should have a firm grasp of modern JavaScript and some knowledge of how to work with
relational databases and the command line.
I explain new and interesting bits of syntax, but this book isn’t primarily about
teaching you how to use JavaScript. It’s about teaching you how to build real applications
by using AdonisJs.
The application we’re going to build is called Threadbear. It’s a play on words,
meant to conjure up thoughts of patchy, knitted teddy bears. We’re going to make an
application through which sellers can register and upload their knitted patterns and
products. Customers will then be able to register and purchase these things.
We’re not going to focus much on design. Instead, we’re going to focus on the
mechanics of commerce applications. Beyond adding a CSS framework, everything is as
the good browser vendors intended. That said, I welcome you to add your own style to
the application
We’ll create a secure registration and login system. We’ll add profile and product
management. We’ll connect the front end to the back end by using WebSockets and
the Fetch API. We’ll design a shopping cart in React and we’ll package static files with a
custom build chain. Finally, we’ll learn how to deploy the application to a virtual server,
and install custom domains and SSL certificates.
It is my hope that by the time you are finished reading this book, you’ll know all you
need to know in order to build your online business.

xiii
CHAPTER 1

Getting Started
Deciding where to start is often the hardest part, don’t you find? In this chapter, we’re
going to get our development tools set up. We’re also going to create a new AdonisJs
application. We’ll finish up by taking a look at the folders of our application and making
a few small customizations.

Note Complex and exhaustive installation instructions are one of the easiest
ways to age a book. I’m not going to belabor the steps for every operating system
and configuration. I’m guessing you know enough about Google to find the help
you need. If you get stuck, ask me for help on Twitter (https://twitter.com/
assertchris) or e-mail ([email protected]).

I nstalling Node.js
As the name implies, AdonisJs is a JavaScript framework. There have been a few
runtimes for JavaScript on the server, but the clear winner is Node.js (https://nodejs.
org/en). You can see what the Node.js web site looks like in Figure 1-1. The latest version
of AdonisJs requires Node 8.0 or newer. That’s because it uses new language features to
make writing code easier and more expressive. We’ll learn about those later.
Node.js is relatively painless to install, despite its size and intricacy. On macOS, you
can run the following:

brew install node

And on Debian or Ubuntu, you can run this:

apt-get install node

1
© Christopher Pitt 2018
C. Pitt, The Definitive Guide to AdonisJs, https://doi.org/10.1007/978-1-4842-3390-0_1
Chapter 1 Getting Started

Note Alternatively, you can install Node.js from a binary at https://nodejs.


org/en/download. There are installers for Windows, so you don’t have to use
macOS or Debian if you don’t want to.

You can check that Node.js is correctly installed by running the following:

node -v
npm -v

Figure 1-1. The Node.js web site

2
Chapter 1 Getting Started

Installing the AdonisJs Command-Line Tool


Setting up a new AdonisJs application requires quite a few steps. Fortunately, there’s a
tool to perform all of those steps for us. We need to install that tool, which also will help
us to create all future AdonisJs applications:

npm install --global @adonisjs/cli

This installs the command-line tool globally, which means we’ll be able to use it
from anywhere on our system. Similarly to the way we check Node.js, we can check to
see whether this tool has been successfully installed by running the following:

adonis --help

This also gives as a sneak peek at the kinds of things we can start to do to an
application. Various commands are available, from creating and running applications to
adding new functionality in existing applications.
For now, we’re just going to create a new AdonisJs application.

Creating a New Application


If you read through the output of that help command, you may have noticed the new
command. It’s what we’re going to use to create a new application:

adonis new threadbear

It’ll take a minute or two to fully install and configure the new application. The
only step I want to talk about for the moment is “generated unique APP_KEY.” AdonisJs
applications have an .env configuration file, which we can use to store sensitive
configuration variables. One of these is called APP_KEY, which is a private key unique to
the application.
Whenever text is encrypted or hashed, this value is used to seed the operation. The
same password, when hashed in two applications (with different APP_KEY values), will
result in different hashes. This is important to know because at times you might need to
compare hashes or decrypt values that have been generated using a different APP_KEY
than the one the command-line tool just made for you.

3
Chapter 1 Getting Started

Note It’s possible to reuse an APP_KEY in multiple applications, but it’s definitely
not recommended. Sharing an APP_KEY should be done only in exceptional
situations and for a limited amount of time. If you reuse keys, you’re increasing the
likelihood that all the applications reusing the key are compromised at the same time.

S
 erving the Application
Now that we’ve created an application, we need a way to view it in the browser. Some
server-side languages use third-party web servers (such as Nginx or Apache) as a kind of
load balancer. PHP and Perl are examples of this.
Things work a bit differently with server-side JavaScript. The foundational example
of how to use Node.js (https://nodejs.org/en/docs/guides/getting-started-guide)
demonstrates how we can make our own HTTP server:

const http = require("http")

const hostname = "127.0.0.1"


const port = 3333

const server = http.createServer((req, res) => {


    res.statusCode = 200
    res.setHeader("Content-Type", "text/plain")
    res.end("hello world")
})

server.listen(port, hostname, () => {


    // server is now running
})

This is quite similar to what AdonisJs does under the hood. This means our server(s)
need to keep the Node.js HTTP script running as what is usually referred to as a daemon.
We’ll unpack that later, but for now we’ll need to make sure adonis serve is running
while we code.
As the message when we run adonis serve --dev says, we can see the new application
by loading 127.0.0.1:3333 in a web browser. We can see what this looks like in Figure 1-2.

4
Chapter 1 Getting Started

Figure 1-2. A new AdonisJs application

E xploring the Code


New AdonisJs applications are as slim as the repository’s name on which they are based.1
They look something like this:

threadbear
↳ node_modules
↳ public
↳ start
↳ .env
↳ .env.example
↳ .gitignore

1
https://github.com/adonisjs/adonis-slim-app

5
Chapter 1 Getting Started

↳ ace
↳ package.json
↳ server.js

As usual, NPM (or Node Package Manager) dependencies are stored in the node_
modules folder. When we run adonis serve --dev, it’s doing little more than running
node server.js.
Static files, such as client-side stylesheets and scripts, are usually placed in the
public folder. More complex applications tend to have build chains, which take source
stylesheets and scripts and combine/compress them into smaller production versions.
AdonisJs favors convention over configuration. This means that it is designed to be
useful out of the box. Sometimes we might need to deviate from the standard configuration.
In new applications, we can do that by customizing the files in the start folder.
Let’s make a few customizations to the application. We’re going to learn about routes
in a while, but we’ll add one in the meantime. The starting routes file resembles Listing 1-1.

Listing 1-1. This is from threadbear/start/routes.js

"use strict"

const Route = use("Route")

Route.get("/", ({ request }) => {


    return "...some html"
})

See that Route.get? We’re going to add another, as shown in Listing 1-2.

Listing 1-2. This is from threadbear/start/routes.js

Route.get("/register", () => {
    return "...form for customers to make new profiles"
})

For now, restart the serve command and go to the address you see in the terminal
window. We can see the text we entered: text that we’re returning from the route, matching
the /register path we specified.
Larger applications require more files than just the ones we have currently. You may
remember that the adonis --help command suggested quite a few make commands.

6
Chapter 1 Getting Started

We can use these to create any number of project files. Though we’re also going to learn
about them later, let’s create a controller:

adonis make:controller PageController

This creates a nested folder structure: app ➤ Controllers ➤ Http ➤


PageController.js.
Similarly, the other make commands usually put the files they create in the app folder,
and create more nested folders if they don’t already exist. There’s quite a rich structure
built up as needed. The pattern is always the same, leading back to the convention-over-­
configuration paradigm.

Note The command-line tools create files in a predictable location. That’s not
to say that we couldn’t change the position and name of these files—just that by
default, they will always be in a predictable configuration.

Let’s make a new command so we can explore more of the starter configuration:

adonis make:command SendReminderCommand

This command creates a new command-line command class, located in app ➤


Commands ➤ SendReminder.js. It automatically strips the Command suffix and gives some
help for how to add the command to Ace.
Ace is a local version of the adonis global command-line helper. We can run it with
the following:

node ace

The output is similar to (though much less than) that of adonis --help. These
commands are similarly built, but the global adonis command has more subcommands
registered within it. ace has only the commands registered for your app.
Sometimes it’s easier not to have to specify that you want to run the command by
using node. In that case, we can make the Ace script executable:

chmod +x ace

7
Chapter 1 Getting Started

We also need to add a hash-bang (#!) to the top of the Ace script, as in Listing 1-3.

Listing 1-3. This is from threadbear/ace

#!/usr/bin/env node

"use strict"

// ...other code

Now we can run Ace by using the following:

./ace

It’s not a huge improvement, but it is an interesting technique to be aware of. Hash-­
bang directives (like this one) can be useful for hiding unnecessary details, such as the
binary we need to run a script, so that these kinds of stand-alone scripts are easier for
others to use.
We’re going to use this trick later, when we work out how to restart the server with
a new routing configuration. In the meantime, let’s follow the advice we received when
we created the command. Let’s change start/app.js to include the new command, as
shown in Listing 1-4.

Listing 1-4. This is from threadbear/start/app.js

// ...other code

const commands = [
    "App/Commands/SendReminder"
]

module.exports = {
    providers, aceProviders, aliases, commands
}

The command code Ace generated resembles Listing 1-5.

Listing 1-5. This is from threadbear/app/Commands/SendReminder.js


"use strict"

const { Command } = require("@adonisjs/ace")

8
Chapter 1 Getting Started

class SendReminder extends Command {


    static get signature() {
        return "send:reminder"
    }

    static get description() {


        return "..."
    }

    async handle(args, options) {


        this.info("...")
    }
}

module.exports = SendReminder

SendReminder extends the built-in Command class. Command does most of the heavy
lifting, but it does require a few properties/getters to be defined:
signature is the name by which the command will be called, but also the arguments
and extra parameters the command accepts.
description is useful when we run ./ace --help. It shows what the command does
and describes what the arguments and parameters are for.
handle is where we put all the code this command needs to use. We’re going to use it
to send reminder e-mails to our customers, but for now it can log text to the console.
We can see the results of this code in Figure 1-3.

Figure 1-3. The output of ./ace send:reminder

9
Chapter 1 Getting Started

Summary
In this chapter, we installed all the requirements for AdonisJs. We created a new
application, and learned how routes and shared code (such as Ace commands) can be
configured in the files within the start folder.
We’ve touched lightly on a few parts of the AdonisJs application structure. In the next
chapter, we’re going to learn far more about defining application routes.

10
CHAPTER 2

Routing
In the previous chapter, we set up our environment and got our first look at the structure
of an AdonisJs application. Now it’s time to add HTTP endpoints to the application. This
is done by adding routes. We’ll learn about all the ways to customize routes, use the data
they hold, and respond to any request.

What Are Routes?


Routes are like glue between the HTTP requests your browser makes and the server code
meant for each request. This isn’t the first time we’re seeing them, either. In the previous
chapter, we created a /registration route (though we didn’t do any meaningful work
through it).
Routes are an essential part of every application, because every application has at
least one of them. In fact, applications can have many routes, and you’re not limited in
the length, complexity, or number of them your application can have.
The Web is built on top of a communications protocol called HTTP. It has quite a lengthy
definition, but the important bits describe how browsers (and other clients) can make text-
based requests to servers. Those requests include details such as the type of request being
made (the request method) and the server address to which the requests should be sent.
Let’s take another look at the route we defined in the previous chapter, in Listing 2-1.

Listing 2-1. This is from threadbear/start/routes.js

Route.get("/register", () => {
  return "...form to make new profiles"
})

11
© Christopher Pitt 2018
C. Pitt, The Definitive Guide to AdonisJs, https://doi.org/10.1007/978-1-4842-3390-0_2
Chapter 2 Routing

We can tell a couple of things about this route, even if we remove all the code inside
() => {...}. The first is that this route responds to GET requests. There are other kinds
of requests, such as POST, PUT, DELETE, and HEAD. The second thing we can tell is that the
request should go to /register.
Routes can also have values embedded in the path, as we’ll see in this chapter.

Planning Routes
We’re going to define a few more customer routes alongside the /registration route we
already defined. Customers will need these to manage their accounts and gain access to
protected profile and product information:

• GET /login: GET is the most common request method on the


Internet. It’s the go-to method for fetching information in a read-only
way. Similarly to the way we used GET to show the registration form,
we’re using it here to show the login form.

• POST /login: POST is more common than GET when it comes to


creating things. In this case, we’d be creating new customer sessions
(and getting back security tokens). It’s not crucial to understand how
we do that right now. All you need to know is that we want to use
POST because we’re making something.

• PUT /logout: PUT is similar to POST in that it’s used for a write
operation. However, whereas POST is often used to indicate that a
whole new thing is being created, PUT is often used to indicate that a
change is being made to something. As you’ll see, we use PUT when
we want to update something that has already been created.

• POST /register: We already have a route for showing the


registration, but this one is for creating a new customer profile.
Notice that we use the POST method, as we’re creating a whole new
customer account.

• GET /forgot-password: When customers forget or lose their


passwords, we need a way for them to request to set a new one. The
only practical way for us to allow this is to send an e-mail to their
address on record, which contains a link (and security token) they can
click. This endpoint should show users a form with which to do that.
12
Chapter 2 Routing

• POST /forgot-password: After the customer has entered their e-mail


address, the form should be posted to this endpoint. The server code
running here will then send them the e-mail. You should start to see
a pattern here: we use GET to show forms, and POST to create new
things from those forms.

• GET /reset-password/{token}: Similarly to the way the customer


requests to set a new password, this endpoint shows the form they
can use to enter a new password. It has an added {token} parameter,
which we’ll learn about shortly.

• PUT /reset-password/{token}: After the customer has entered a


new password, the form can be posted to this endpoint. Because the
customer’s profile already exists (and we want to make an update to
it), we use the PUT request method.

• GET /{user-name}: After the customer has a profile, we want them


to be able to see what information is visible on it. This is where the
customer will see their protected information, and where other
customers will be able to see details marked as open to the public.

• PUT /{user-name}: Should the customer wish to change details


about their account, they would be able to do so through forms that
send their data to this endpoint. Because it’s a partial update, we use
the PUT method.

• DELETE /{user-name}: Customers should also be able to delete


their profiles, which is a good opportunity for us to use the DELETE
method. It acts a lot like the GET method, except that it is not read-­
only. Deletes are serious business, so we should confirm whether the
customer initiated the process by accident or on purpose.

• GET /{user-name}/products: In our design, customers are also


sellers. They’ll be able to create new products (which is an entirely
optional part of their experience), and those products will be
accessible through this endpoint.

• POST /{user-name}/products: Should the customer want to create


a new product, they’ll be able to do so via this endpoint. Because
they’re creating a whole new product, we use the POST method.

13
Chapter 2 Routing

• GET /{user-name}/{product-name}: If a customer wants to find out


more details about a specific product, they will be able to do so by
using this product-specific, customer-specific endpoint.

• PUT /{user-name}/{product-name}: Similarly, if a customer wants


to update the details of a product, they should be able to do so via a
PUT request to the same endpoint. It’s a partial update, or else we’d
use the POST method.

• DELETE /{user-name}/{product-name}: Finally, if a customer wants


to delete a product, they should use the DELETE request method on
this endpoint.

Note There’s a fine line between respecting a seller’s desire for privacy and
other customers’ right to access content they’ve purchased. It is right for us to
immediately delete products and customer profiles at the will of the customer. It’s
also important for us to preserve the ability to download purchased content after
a profile has been deleted or a product removed from sale. We’ll cross this bridge
when we get to it, but it’s important to remember these rights and responsibilities
when we design the application.

D
 efining Routes
Now that we’ve planned the routes we’ll begin our application with, it’s time to define
them in code. We’ll begin with the profile routes, shown in Listing 2-2.

Listing 2-2. This is from threadbear/start/routes.js

Route.get("/login", () => {
  // show login form
  return "GET /login"
})

Route.post("/login", () => {
  // create new customer session

14
Chapter 2 Routing

  return "POST /login"


})

Route.put("/logout", () => {
  // expire current customer session
  return "PUT /logout"
})

Route.get("/register", () => {
  // show registration form
  return "GET /register"
})

Route.post("/register", () => {
  // create new customer profile
  return "POST /register"
})

Route.get("/forgot-password", () => {
  // show forgot password form
  return "GET /forgot-password"
})

Route.post("/forgot-password", () => {
  // create new password reset token and send e-mail
  return "POST /forgot-password"
})

Each of these routes follows the pattern I just described. They will grow to contain
the functionality of the application, but in the meantime they just return strings. This is
immediately useful for testing, covered next.

Testing Routes
We’re going to take a brief detour from our route definitions to testing. This book has no
chapter dedicated to testing, because I believe it’s better to always be asking ourselves
how we plan to test the code we’re writing.

15
Chapter 2 Routing

There are many schools of thought when it comes to testing. I’m not going to dwell
on any of them (because we don’t have the time, and we need to stay focused), but I will
say that no one approach to testing is the best. Having any tests is better than having
none, and thinking about tests early and continuously has caused me to write better
code. I recommend this approach.
The jury is still out on which testing framework is the best. For now, we’re going to
use a framework called Mocha (https://mochajs.org). To install it, we need to run the
following command:

npm install --save-dev mocha

This gives us access to a few tools we can use for testing. Now let’s create a test file to
hold our first test, as shown in Listing 2-3.

Listing 2-3. This is from threadbear/test/routes.js

const assert = require("assert")


const http = require("http")

require("dotenv").config()

const shouldBeOk = (method, path, done) => {


  http
    .request(
      {
        host: process.env.HOST,
        port: process.env.PORT,
        method,
        path,
      },
      response => {
        assert.equal(200, response.statusCode)
        done()
      },
    )
    .end()
}

16
Chapter 2 Routing

const shouldHaveMessage = (
  method,
  path,
  message,
  done,
) => {
  http
    .request(
      {
        host: process.env.HOST,
        port: process.env.PORT,
        method,
        path,
      },
      response => {
        let data = ""

        response.on("data", chunk => {


          data += chunk
        })

        response.on("end", () => {
          assert.equal(message, data)
          done()
        })
      },
    )
    .end()
}

describe("GET /login", () => {


  it("should have the correct status (200)", done => {
    shouldBeOk("GET", "/login", done)
  })

  it("should have the correct message", done => {


    shouldHaveMessage(
      "GET",
17
Chapter 2 Routing

      "/login",
      "GET /login",
      done,
    )
  })
})

We begin by importing the assertions and HTTP libraries via require statements. We
also import the dotenv library and immediately call the config method. This loads all
the environment variables in our .env file so we can build a URL from the HOST and PORT
variables.
We follow this up by creating the shouldBeOk and shouldHaveMessage helper
functions. The first checks whether a request to an address returns a response with a 200
status code. This would indicate that the request returned successfully, which tells us
that the route is defined.
The shouldHaveMessage function tells us whether a request to an address returns a
message we expect. We’ve defined our routes to return simple messages that describe
their method and path, so we can use shouldHaveMessage to make sure the requests
match the messages we expect them to.
We’ve also defined our first set of tests using the describe and it functions. Mocha
provides these for us, so we don’t have to import them. We can duplicate these tests for
each route, as demonstrated in Listing 2-4.

Listing 2-4. This is from threadbear/test/routes.js

describe("POST /login", () => {


  it("should have the correct status (200)", done => {
    shouldBeOk("POST", "/login", done)
  })

  it("should have the correct message", done => {


    shouldHaveMessage(
      "POST",
      "/login",
      "POST /login",
      done,
    )

18
Exploring the Variety of Random
Documents with Different Content
fliessen ihm zahlreiche wasserreiche Bäche zu. Er soll in der
Regenzeit ziemlich weit aufwärts mit Kanus befahrbar sein und keine
Schnellen besitzen.
Unweit Ruwenga soll eine heisse Quelle entspringen. Die
wenigen Tage, die ich am Ta n g a n yika zubrachte, sind nicht im
Stande der ziemlich reichen Litteratur über diesen See Neues
hinzuzufügen. Von früh 10 Uhr bis Sonnenuntergang wehte im
September ein kräftiger Südwind, der in dieser Jahreszeit
regelmässig auftreten soll. Das Wasser war leicht brackisch, aber
geniessbar. Nach Aussage der Eingeborenen fällt der See stark und
breite Sanddünen zeigen die Fläche, die er früher bedeckte. Auch
die von Hore und Livingstone gesehene Insel konnte ich nicht mehr
wahrnehmen.
Was die o r o g r a p h isch e G l ie d e r u n g anbelangt, so trifft man
in Ost-Ussui leicht gewellte Landschaften, die von einzelnen meist
N. N. O. verlaufenden Kämmen durchschnitten werden. Weiter
landeinwärts treten diese näher aneinander und nehmen
Plateaucharakter an. In Urundi ist das allmählich ansteigende Land
durch die Erosion in ein ziemlich regelloses Gewirre von Kuppen
verwandelt, in welchem die meridionale Kammrichtung kaum noch
erkennbar ist. Den Westrand bildet der riesige, fast 3000 m hohe
Wall der Missosi ya Mwesi, der jenseits steil nach dem
Centralafrikanischen Graben abstürzt.
Durch den Tanganyika und das Russisi-Thal, durch den Albert-
Edward- und Albert-See charakterisirt, bildet der
Ce n t r a la f r i ka n isch e G r a b e n, wie schon Dr. Ha n s Me y e r
ausgeführt, eine mehr lokale aber kaum weniger grossartige
Störungslinie als der Ostafrikanische. Die Seen sind sämmtlich
durch leicht brackisches Wasser ausgezeichnet und der Tanganyika
legitimirt sich durch die Fauna deutlich als Relicten-See. Zum
Unterschied vom ostafrikanischen Graben, bei welchem der
Westrand allein durchwegs scharf ausgeprägt ist, scheinen hier
beide Ränder in gleicher Deutlichkeit aufzutreten. Am Tanganyika
sowohl wie am Albert- und Albert-Edward-See tritt der Westrand als
schroffe Mauer auf; ebenso präsentirt sich der Ostrand im Süden als
die Missosi ya Mwesi, im Norden als Ruvensori bis über die
Schneegrenze aufragend.
Die von Suess vermuthete Aufwulstung der Grabenränder, tritt
hier bei den Randgebirgen deutlich auf. Ueberall bildet die Höhe des
Abfalls auch die Wasserscheide, auf der einen Seite die des Kongo,
auf der anderen die des Nil, dessen Ursprung sich in nächster Nähe
des Grabens befindet. Aehnlich wie der Gurui sich in der Sohle des
Ostgrabens erhebt, so ragen hier die Mfumbiro-Vulkane auf, einen
deutlichen Beweis für den Bruchcharakter dieser Senkung liefernd.
Von dem östlichen Randwall des Tanganyika zweigt jener Kamm
ab, welcher die Wasserscheide zwischen Kagera und Mlagarassi
bildet und erst steil und felsig ist, dann immer mehr abflacht. Südlich
davon sind nur niedrige Hügelzüge vorgelagert, aus welchen man in
das Flachland von Unyamwesi tritt.
Der g e o l o g isch e B a u ist durch das Vorherrschen
krystallinischer Gesteine bezeichnet; nur selten und meist an
grossen Flussläufen, wie dem Kagera und Akanyaru, werden die
liegenden plutonischen Gesteine, Granit und Diabas, durch die
Erosion blosgelegt. In Ussui und Urundi bis zum Akanyaru ist
Quarzit vorherrschend mit meist N. N. O. — S. S. W.-Streichen und
steilem W. N. W.-Fallen. Derselbe ist vielfach mergelich verwittert
und oft mit dicken Lateritmassen überlagert. Vereinzelt tritt Gneiss,
Glimmerschiefer und Urthonschiefer in gleicher Lagerung auf,
letzterer am Muhembaberg graphithaltig. In Ruanda tritt Gneiss auf,
während im südlichen Urundi wieder Quarzit vorherrscht. Auch in
Uha steht krystallinisches Gestein an, welches vielfach
eisenschüssig verwittert ist und sich an das Granitgebiet von
Unyamwesi anschliesst. —
Wahrscheinlich paläozoische Sedimente treten an einigen
Punkten Urundi's auf, Kalke fand ich nur in Uha, doch sollen solche
auch bei Ruvenga am Westufer des Tanganyika anstehen.
Das K l i ma ist in ganz auffallender Weise durch die
Wasserscheiden beeinflusst, indem das Gebiet des Kagera fruchtbar
und reicher an Niederschlägen ist als das Tanganyika-Gebiet,
während das Urigi-Gebiet etwa die Mitte zwischen beiden einhält. —
Der Grund liegt wohl hauptsächlich in der verschiedenen Seehöhe,
möglicherweise auch in herrschenden Windrichtungen, deren
Erforschung der Zukunft vorbehalten bleibt.
An das Klima ist die Vegetation gebunden, welche den
L a n d sch a ft sch a r a kt e r bestimmt. Durch einen Steppenstreifen ist
das Nyansa-Ufer von Ussui getrennt, ein vorherrschend offenes,
grasiges Gebiet in dem nur Siedelhaine und vereinzelt hohe
Laubbäume aufragen. Diese verschwinden im centralen Ussui, das
einen sehr dürren Charakter mit rothem, eisenschüssigem Gerölle
und spärlichem Gestrüpp an den Hängen besitzt. West-Ussui und
Urundi sind fast ganz Weideland, mit Wiesen die alljährlich
abbrennen und deren Eintönigkeit nur durch die dunkelgrünen
Papyrus-Sümpfe und Siedelhaine unterbrochen wird. Erst an den
Hängen der Missosi ya Mwesi tritt Bergwald mit zahlreichen Bambus
auf. Das südliche Urundi, welches schon dem Mlagarassi-Gebiet
angehört, ist ziemlich trocken und steinig. Uha ist ein Waldland; auf
ungeheuren Strecken bedeckt mit wasserarmen, lichten
Laubwäldern, in welchen Caesalpiniaceen vorherrschen und welche
als Miombowälder in das östliche Unyamwesi übergreifen. Die
einzige Unterbrechung dieser Wälder bilden in Uha ausgedehnte,
zur Regenzeit versumpfte Savannen. Da das ganze Gebiet mehr
oder weniger dicht besiedelt ist, so ist Wild ziemlich spärlich und
findet sich nur in den Wildnissen von Uha. —
Wenn wir das ganze Gebiet überblicken, so finden wir in
demselben eine uralte Kontinentalmasse, in welcher Sedimente nur
eine untergeordnete Rolle spielen und die durch das Vorherrschen
primärer Gesteine ausgezeichnet ist. Die gebirgsbildenden Motoren,
die in Europa und Asien durch Faltung das Antlitz der Erde
veränderten, übten hier keine wahrnehmbare Wirkung. An ihre Stelle
traten grossartige Störungslinien, welche das Land, in geologisch
jüngster Zeit, in einzelne Schollen zerrissen und es zu einem der
merkwürdigsten und bedeutungsvollsten Gebiete der Erdoberfläche
machten.

Kapt. Spring photogr.


Granitfelsen in Usukuma.
[←] VIII. KAPITEL.

Die Völker des abflusslosen Gebietes.


Die Massai. — Die Wandorobo. — Die Wataturu. — Die Wafiomi. — Die
Wambugwe. — Die Wanyaturu. — Die Wassandaui. — Wanderungen der
Stämme.

Wie aus der allgemeinen Beschreibung hervorgeht, ist das


abflusslose Gebiet durch das immerhin bedeutende Auftreten von
Steppenstrichen bezeichnet. Zwar sind dieselben nicht annähernd
so ausgedehnt als man vermuthete und viele Gegenden, die als
Wüsten bezeichnet wurden, erwiesen sich als ausserordentlich
fruchtbar, ja mit als die besten Länder Ostafrika's. Aber immerhin ist
das Gebiet, welches menschlicher Siedelung einen günstigen Boden
bietet, ein beschränktes und selbst von diesem ist nur ein geringer
Theil ständig bewohnt, das übrige bildet den ungeheuren Weide-
und Jagdgrund nomadischer Volksstämme. Gerade die schwierige
Zugänglichkeit des Gebietes hat jedoch seine Bewohner in einer
Ursprünglichkeit und Unberührtheit erhalten, wie sie in heutiger Zeit
nur selten anzutreffen ist.
Mehrere der Stämme des abflusslosen Gebietes werden hier
zum ersten Mal genannt, von den meisten anderen kannte man nur
den Namen, ohne von ihrer Lebensweise und ihrer
ethnographischen Zugehörigkeit auch nur das Geringste zu wissen,
da kein Reisender dieselben vorher gesehen hatte.
Dies ist allerdings nicht
bei jenem Stamme der Fall,
der dem ganzen Gebiete
gewissermaassen seinen
Stempel aufgedrückt hat,
bei den Ma ssa i.
Gründliche Forscher, wie
Krapf, Dr. Fischer, Thomson
und v. Höhnel, haben
diesen Stamm in seinen
nördlichen Wohnsitzen
kennen gelernt und bei der
ausserordentlichen
Massai-Knabe.
Einheitlichkeit der Massai
haben die Beschreibungen die sie entworfen im Allgemeinen auch
für unser Gebiet Geltung. Dabei haben diese Forscher die Massai in
ihrer Glanzperiode gesehen, während ich auf der letzten Reise sie
im tiefsten Elend fand.
Wenn ich dennoch nachfolgend eine Beschreibung dieses
merkwürdigen Hirtenvolkes gebe, so geschieht dies, weil ich durch
monatelangen, täglichen Verkehr mit den Massai-Hirten der
Expedition, sowie durch einen selten vorzüglichen Dolmetsch in der
Lage war, manches zur Ergänzung der Berichte obengenannter
Reisenden zu erfahren.
Die Ma ssa i- Vö lke r zerfallen in zwei Gruppen, die Mb a r a w u i,
von den Küstenleuten Wa ku a vi genannt und die Massai im
engeren Sinne. Die Sprache der beiden Stämme ist dialektisch
verschieden, auch finden sich Unterschiede in den Sitten und vor
Allem ist das Stammesbewusstsein beider Völker so stark
ausgeprägt, dass eine Unterscheidung derselben berechtigt
erscheint. Der Swahíli-Name »Mkuavi« wurde mir von einem
gleichnamigen hohen Laubbaum mit rothen Früchten abgeleitet, der
in Bondeï und im Hinterlande von Mombas gedeiht und von den
Waschambaa Mambia genannt wird. Nach diesem Baum benannten
die Küstenleute die hochgewachsenen Mbarawui, das erste Massai-
Volk mit dem sie in Berührung kamen.
Die Nachrichten, welche ich über die Kämpfe dieser beiden
Stämme erfuhr, lassen sich so ziemlich mit den von Thomson
erkundeten in Einklang bringen.
Die Mbarawui sassen ursprünglich zu beiden Seiten des Pare-
Gebirges und wohl auch in der Kiwaya-Steppe, von wo aus sie das
Küstengebiet zu verheeren pflegten. Die Massai lebten am Manyara-
See, in der Sogonoi-Gegend, in Kisongo und nordöstlich vom
Kilimanjaro bis Ukambani hin. Nach Thomson litten die Wakuavi sehr
unter Dürre und hatten sich eine Niederlage von den Wagogo geholt.
Wie man mir mittheilte, drängten die von Süden kommenden
Wambugwe auf die Massai und vertrieben sie vom Manyara. Mag
nun dieser, oder ein anderer Grund als Veranlassung gedient haben,
genug, die Massai bekriegten die ohnehin geschwächten Wakuavi
und vertrieben sie aus ihren Wohnsitzen. Ein Theil wurde versprengt
und fand in Usegua, Unguu sowie im Pare-Gebirge (als Wambugu)
eine Zuflucht als halbansässige Viehzüchter oder schloss sich den
Bantu-Ackerbauern von Taveta, Kahe, Ober- und Unter-Aruscha an.
Der grösste Theil der Wakuavi zog jedoch nach Nguruman, wo
damals noch keine Massai lebten. Dort theilten sie sich: eine
Abtheilung besiedelte Ndare Serian (Friedens-Schaf) am Ngare
dabash, die andere die Gegenden am Naivascha-See, vor Allem
Guas Ngischu. Dort fand der von Thomson erwähnte
Verzweiflungskampf mit den Massai statt. Besiegt zog die
Hauptmasse der Guas Ngischu-Wakuavi nach Leikipya, dem
»Neuland«, wo sie mit der Zeit wieder grosse Macht erlangten.
Andere schlossen sich den Bantu (Wassegeju) von Nguruman und
Sonyo, andere den, wahrscheinlich den Kamassia verwandten
Urbewohnern von Njemps am Baringo und den Kavirondo an.
Theilweise gingen sie in diesen Ackerbaustämmen auf, nicht ohne
denselben in Tracht und Sitten, vielfach selbst in der Sprache ihr
Gepräge aufzudrücken. Auch in Ngoroïne findet man zahlreiche
angesiedelte Wakuavi.
Erst nach Verdrängung der Wakuavi aus Guas Ngischu
besiedelten die Massai das Plateaugebiet, Mutier, Ndasekera und
Serengeti, die ursprünglichen Wohnsitze der Wataturu.
Das weite Massai-Land, welches früher der ungeheuere
Weideplatz der Massai-Heerden war, ist jetzt in verschiedene
Distrikte wie Kiwaya, Simangiro, Mutyek u. s. w. getheilt, deren jeder
ein bestimmtes Schildwappen führt, an dem sich die Krieger
erkennen. Innerhalb der einzelnen Distrikte sind stets fast alle
Massai-Stämme vertreten, die als mehr oder weniger vornehm
gelten und wahrscheinlich noch aus der unbekannten Urheimath der
Massai stammen. So giebt es überall Vertreter der Stämme
Muleïlyan, Leisseri, Leitoyo, Mamasita, Mágesen, Marumwai,
Lugumai, Maguveria und des Schmiedestammes der Elkonono, die
ebenfalls Massai sind, aber von den anderen verachtet werden.
Die Massai sind meist hochgewachsen, schlank und langbeinig.
Ihre Körperformen sind selten voll, sondern auch bei Männern
vielfach zart und weibisch, doch oft von grosser Schönheit. Dennoch
besitzen sie bedeutende Muskelkraft und Ausdauer. Die
Extremitäten sind zierlich und schmal, die Haut ist meist dunkler als
chokoladebraun und erstaunlich weich und sammetartig. Der
Gesichtstypus variirt sehr. In Sogonoi und Kiwaya, also im
Steppengebiet, findet man oft negerhafte Züge, hier treten auch
vollere Körperformen auf. Fast rein hamitisch sehen die Plateau-
Massai, also die von Mutyek und Serengeti aus. Dieselben haben
regelmässige Züge, schmale Nasen und glänzende, schwarze
Augen die manchmal leicht schiefgestellt sind. Im Alter werden die
Züge hart und oft adlerartig scharf. Häufig trifft man sogenanntes
Hamiten-Haar. Wenn der Kopf frisch rasirt ist, so erscheint das
nachwachsende schwarze Haar bis zur Länge von ca. 1 cm völlig
glatt und bekommt dann erst eine leichte Kräuselung, die an die
Kraushaare mancher Europäer erinnert. Beim echten Wollhaar
erscheinen dagegen schon die ersten Haaransätze gekräuselt.
Dieses, an der Küste bei Mischlingen von Arabern und Negern nicht
seltene Hamiten-Haar findet sich bei den Plateau-Massai häufig,
etwas seltener bei jenen des Tieflandes die häufig Wollhaare haben.
Im Allgemeinen machen die Massai den Eindruck eines
hamitischen Stammes, der in verschiedenen Gegenden mehr oder
weniger starke Blutmischungen mit Bantu erhalten hat. Den
tiefschwarzen, typisch negerhaften Sudanesen, welchen sie
sprachlich so nahe stehen, gleichen sie physisch in keiner Weise.
Das Haar wird von jungen Leuten kurz getragen. Krieger lassen
dasselbe lang wachsen und flechten es in fadendünne Strähnen, so
dass es von weitem wie schlichtes Haar aussieht. Diese Strähnen
werden mit Fett und rother Lehmfarbe eingerieben und verschiedene
Frisuren daraus geflochten, bei welcher die mit langem,
bastumwundenen Zopf überwiegt. Die eigenthümliche Art der
Beschneidung (Incision) beschreibt Thomson ausführlich.
Die Weiber tragen den Schädel rasirt. Die beiden oberen,
vorderen Schneidezähne werden bei beiden Geschlechtern
vorgebogen, die entsprechenden unteren ausgebrochen, doch ist
diese Sitte nicht mehr allgemein üblich. Die Ohrläppchen werden
durchlöchert und bis zur Länge von 10 cm und darüber ausgedehnt.
Darin tragen die Krieger Eisenspiralen, an welchen Kettchen
hängen, die Weiber tellerförmige Eisenspiralen, die oft so schwer
sind, dass sie durch einen über den Schädel gelegten Riemen
gehalten werden müssen.
Um den Hals tragen die Weiber Bänder aus steifem Leder, auf
welchen weisse und rothe Glasperlen genäht sind und von denen
Eisenkettchen und Glasperlen herabhängen, die Verheiratheten
auch einen tellerförmigen Kragen von dickem, gewundenem
Eisendraht. Am Oberarm tragen die Krieger ein Armband aus Horn,
am Unterarm manchmal einige Glasperlen. Die Weiber umwinden
sich den Unterarm und Unterschenkel mit mächtigen Manschetten
aus Eisendraht.
Die Kl e id u n g besteht bei Kriegern aus einem kurzen
Lederüberwurf, der die linke Schulter freilässt und niemals die
Schamtheile bedeckt. Der selbe ist manchmal aussen behaart und
aus verschiedenfarbiger Rindshaut gefertigt. Oefter tragen sie am
Hintertheil ein dreieckförmiges Schürzchen als Sitzmöbel. Die
älteren Leute haben längere Ledermäntel, ebenso die Weiber,
deren, den Busen verhüllende Lederkleidung an den Hüften durch
einen Gürtel zusammengehalten wird. An den Füssen trägt man
häufig kräftige Ledersandalen.
Der Kriegsschmuck der Massai ist schon oft beschrieben und
abgebildet worden. Gerade diese zahlreichen Abbildungen können
jedoch die Ansicht hervorrufen, dass dieser wilde, aus Colobusfellen,
Straussfedern u. s. w. gebildete Kriegsschmuck allgemein getragen
wird. Dies ist jedoch keineswegs der Fall. Ich habe auf dieser und
auf meinen früheren Reisen öfter Massai am Kriegspfade gesehen,
aber nicht einen einzigen im vollen Kriegsschmuck. Einer oder der
andere — von 100 Kriegern etwa ein Dutzend — trugen den
bekannten Federschmuck aus Straussfedern, der das Gesicht
einrahmt, die übrigen zogen in gewöhnlicher Tracht ins Feld und
bemalten sich höchstens mit weissem Mergel an den Beinen.
Körperbemalung ist überhaupt allgemein üblich und wird mit Fett
und rother Lehmfarbe ausgeführt. Eine Körperreinlichkeit kennen die
Massai nicht. Mein ältester Rinderhirt, ein weisshaariger Elmoruo,
gestand mir ein, dass er sich im Leben noch nie gewaschen habe.
Deshalb wimmeln denn auch die Haare, Lederkleider, ja selbst der
Eisenschmuck der Weiber von Ungeziefer.
Durch K r a n kh e it e n wurden die Massai früher wohl nicht viel
geplagt, die empfindlichsten waren die Augenleiden, welche durch
die zahllosen Fliegen verbreitet werden und oft zur Erblindung
führen. So zäh und gesund die Massai im eigenen Lande sind, so
wenig widerstandsfähig zeigen sie sich in anderen Klimaten. Am
besten halten noch die Steppen-Massai einen Klimawechsel aus, die
Plateaubewohner gehen jedoch überall in der Niederung, besonders
an der Küste oder am Victoria-Nyansa, rasch ein. Gegenwärtig
leiden alle Massai an einer grossen Krankheit: dem Hunger.
Was den Ch a r a kt e r der Massai anbelangt, so ist für denselben
vor Allem ein grosser Eigendünkel bezeichnend, der sie auf alles,
was nicht Massai ist, mit Verachtung blicken lässt. Besonders die
Krieger haben eine stolze, freie Haltung, blicken jedem Fremden
gerade ins Auge und bringen dadurch, im Gegensatz zu anderen
Schwarzen, einen angenehmen Eindruck hervor. Sie wirken auch
auf ihren Raubzügen hauptsächlich durch den moralischen Eindruck
eines trotzigen, rücksichtslosen Vorgehens, dem schwache
Gemüther nicht gewachsen sind. Wo sie aber auf kräftigen
Widerstand stossen, wie z. B. bei den Wambugwe, verwandelt sich
ihre »Kühnheit« sofort in jämmerliche Feigheit.
Der nomadischen Lebensweise entsprechen die Wo h n si tze,
oder besser gesagt die Lager der Massai. Sie bestehen aus 40 bis
60 kreisförmig angeordneten Hütten, die einen Viehhof umsäumen.
(Abb. pag. 32). Die Hütten haben oblongen Grundriss, sind ca. 1,20
m hoch und durch ein Gerippe von Zweigen gestützt. Dieses wurde
früher mit Kuhmist und Lehm, jetzt meist mit Stäbchenmatten und
Fellen überzogen. Das Thor, durch welches man seitlich, wie in ein
Schneckenhaus, eintritt, liegt an der Innenseite, der Hüttenraum ist
in zwei Theile getheilt.
Beim Abzug bleiben diese Hütten stehen und finden sich als
Wahrzeichen früherer Siedelungen überall im Massailand verstreut.
Nur Felle und Hausgeräth werden auf Esel und Rinder gepackt und
mitgenommen.
Das ganze Leben der Massai dreht sich um die Vie h zu ch t, die
J a g d war früher nahezu verpönt und wird erst in neuerer Zeit auch
von den El Moran (Kriegern) betrieben. Die Hauptpflege wurde den
Rindern zu Theil, deren Zahl durch die Raubzüge ungeheuer
anwuchs. Daneben hält man auch Ziegen, Schafe und Esel. Die
Zuchtwahl scheint den Massai nicht unbekannt, wenigstens sah ich
öfters Schafböcke, welchen man steife Lederschürzen umgebunden
hatte, um eine Fortpflanzung zu verhindern. Die Rinder gehören
durchweg der Zebu-Rasse an, Anklänge an den bei den Watussi
auftretenden Sangatypus der Galla-Länder fehlen gänzlich. Der
Grund liegt jedenfalls in den Raubzügen, die den Massai massenhaft
Rinder der ansässigen Völker zuführten, wobei etwa vorhandene
ursprüngliche Formen aufgingen. Die Esel sind kräftig, untersetzt,
von grauer Farbe und sehr ausdauernd. Bei den Krankheiten der
Hausthiere werden verschiedene Arzneimittel angewendet. Den
Rindern pflegt man mit einem eigenen kurzen Pfeil eine Ader zu
öffnen, um deren Blut zu trinken, hierauf wird die Wunde wieder
zugeheilt. Die Tödtung der Rinder geschieht durch einen Stich ins
Genick. Das Melken der Kühe ist nur Nachts gestattet.
An G e r ä t h e n besitzen die Massai sehr wenig und nichts selbst
gefertigtes, mit Ausnahme der Schmucksachen. Schlechte
Thontöpfe liefern ihnen die Wandorobo, Kalebassen erhalten sie von
den ackerbautreibenden Stämmen. Als Wa ffe n dienen den
Kriegern Speer, Schild, Schwert und Keule, den älteren Männern
Bogen und Pfeile. Die Eisengeräthe fertigen die Elkonono, doch
glaube ich nicht, dass dieselben das Herstellen von Eisen aus dem
Erz verstehen. Vielmehr wird Eisen meist als Eisendraht von
Karawanen importirt oder in anderer Form von Ackerbauern
bezogen. Die schönsten der grossen breitklingigen Massai-Speere
machen übrigens gar nicht die Massai, sondern die Wadschagga
und Ober-Aruschaner, die auch die Eisen- und Kupferkettchen
fertigen. Der Schild wird aus Büffelhaut von den Wandorobo gefertigt
und mit Erdfarben in den Wappenmustern bemalt. Dieselben gelten
für bestimmte Distrikte, z. B. kann man einen Mutyek-Schild sofort
von einem aus Sogonoi erkennen. Die Keule ist aus hartem Holz
und dient weniger als Waffe, als zum agiren bei Reden, sie wird
auch meist nur von Anführern getragen. Die Elmoruo (die älteren
Leute) tragen leichte Bogen und Pfeile in Holzköchern.
Bei der G e b u r t
eines Kindes
umgeben verwandte
Frauen die Pfeil zum Aderlassen der Rinder, Massai.
Wöchnerin, Männer
dürfen die Hütte nicht betreten. Knaben sind beliebter als Mädchen,
doch soll Kindesmord niemals vorkommen. Ist die Geburt glücklich
vorüber, so wird für den Vater ein Rind, für die Mutter ein Schaf
geschlachtet. Der Knabe, Layok, läuft völlig nackt und erhält
Unterricht im Viehtreiben und Speerschwingen, manchmal wird er
wohl auch bei Kriegszügen mitgenommen. Das Mädchen, Ndoye,
verbringt die Jugend bei der Mutter, bis sie mit ca. 12 bis 13 Jahren
als Ndito in den Elmorankraal kommt. Auch der Knabe wird schon
mit 16 Jahren für erwachsen gehalten, was durch ein Fest gefeiert
wird. Die älteren Leute versammeln sich, schlachten ein Rind und
trinken drei Tage lang Honigwein. Dann werden die jungen Leute
durch einen Kundigen — nicht den Zauberdoktor (Laibon) — nach
Massai-Art beschnitten und die Zähne und Ohren in der oben
erwähnten Weise behandelt. Bis zur Heilung der Wunde leben sie
abseits im Busch und nähren sich von kleinen Vögeln, deren Bälge
sie um den Kopf gewunden tragen.
Dann wird der junge Mann in den El mo r a n kr a a l aufgenommen
und lebt zusammen mit den Nditos. Zeugt er ein Kind, so ist es
üblich, dass er das Mädchen heirathet und Elmoruo wird, doch kann
er sich auch durch ein Geschenk an den Vater loskaufen. Die
Nahrung des Elmoran ist eine rein animalische; ausser Fleisch, Blut
und Milch darf er nur Honig und Zuckerrohr geniessen. Wildfleisch
und vor allem Getreide sind ihm gänzlich verpönt, so dass derjenige,
welcher als Krieger »Ngúruma« (Getreide) isst, keine Frau bekommt.
Das Blut wird in der oben beschriebenen Weise direkt aus der Ader
des Rindes getrunken. Fleisch wird an Stöcken gebraten. Milch wird
im Allgemeinen nicht gekocht, nur für Verwundete mit Blut vermischt
und warm gemacht, ein Gebrauch, der jedoch von Fremden
(Wagogo?) entlehnt sein soll. Sonst darf der Elmoran am selben
Tage nicht Fleisch bezw. Blut und Milch zusammen geniessen.
Aller Nahrung wird ein aus einer Akazienrinde gewonnenes Mittel
»Mokota« beigemengt, welches Erbrechen und Abführen, sowie bei
reichlichem Genuss eine Art Berserkerwuth hervorbringt, in welcher
die Krieger vor Aufregung zittern und wobei ihnen Speichel aus dem
Munde fliesst. Fleisch mit Mokota und Milch soll jedoch Ruhr
erzeugen, woher der obige Gebrauch stammt, an demselben Tage
entweder nur Fleisch oder nur Milch zu geniessen. Auch die Weiber,
vor allem die Nditos, geniessen Mokota, dürfen aber auch
Pflanzenkost zu sich nehmen.
Im Kraal selbst darf keine Nahrung genommen werden. Um ein
Rind zu schlachten, ziehen die Krieger mit einigen Nditos in den
Busch, errichten mehrere leichte Grashütten und verschlingen dann
unglaubliche Mengen Fleisch. Grosse und kleine Bedürfnisse
verrichten die Massai stehend mit ausgespreizten Beinen.
Der Austritt aus dem Elmoran-Verbande erfolgt in verschiedenem
Alter, meist jedoch früh, mit ca. 30 Jahren. Dem Massai behagt das
Elmoran-Dasein, welches in Kriegszügen und faulem Umherlungern
mit den Nditos getheilt ist. Die Väter jedoch, besonders wenn sie
grosse Heerden besitzen, sehen ihre Söhne nicht gern in diesem
unsteten, gefährlichen Stande und entführen sie nicht selten mit
Gewalt aus dem Kraal; das Wahrzeichen des Elmoran, das Haar,
wird abrasirt und der Elmoruo, alte Mann, ist fertig. Wer freilich einen
armen Vater hat und auch bei den Raubzügen nicht viel Rinder
bekommt, der bleibt bis in reiferes Alter Elmoran.
Der El mo r u o muss sich sofort um eine Frau umsehen, die er
aus den Nditos seines eigenen Stammes erwählt. So heirathet ein
Muleïlyan nur eine Muleïlyan, nicht aber etwa eine Leiseri. Der
übliche Brautpreis besteht aus zwei Kälbern, zwei Kühen, einem
grossen Stier, einem Ochsen und einer Kuh mit kleinem Kalb. Am
Hochzeitstage wird ein Ochse geschlachtet. Die Brautleute
verbringen hierauf drei Tage in einer Hütte; isst der Mann, so darf die
Frau nicht zusehen und umgekehrt. Für die Nahrung des Elmoruo
besteht ebensowenig eine Vorschrift, wie für die der verheiratheten
Frauen, Siangiki. Auch darf er Honigwein trinken und Tabak
schnupfen. Letzteres ist dem Massai-Elmoran verboten, dem
Mbaravui- (Wakuavi) Elmoran dagegen gestattet. Die Elmoruo und
Siangiki geniessen auch Mokota, doch in geringen Mengen.
Vielweiberei ist üblich, Scheidung häufig und mit keinen Umständen
verbunden. Den Männern liegt hauptsächlich die Viehzucht ob, den
Weibern das Erbauen der Hütten und Treiben der Esel auf der
Reise.
Bei Kr a n kh e it e n werden verschiedene Arzneimittel, vor allem
die Universalmedizin Mokota gegeben, auch pflegt man den kranken
Theil zu massiren und mit Dornen zu stechen. Dagegen ist das sonst
so verbreitete Schröpfen und Klystiren unbekannt.
Ein To d t e r wird mit Rindsfett bestrichen, in eine Haut gehüllt und
unweit des Kraals ausgesetzt. Wenn ihn die Hyänen nicht gleich am
ersten Tage fressen, so gilt dies als Unglückszeichen; es werden vier
Rinder geschlachtet und das Fett auf den Todten gestrichen.
Der Familie, Weib und Kind, ist der Massai sehr zugethan und
man kann oft harte Krieger plötzlich zur tiefsten Rührung übergehen
sehen, wenn sie lange vermisste Familienglieder wiedersehen. Mit
diesem anscheinend gutmüthigen Zug kontrastirt ihre Blutgier allen
Fremden gegenüber, welche sie nicht nur bewaffnete Feinde,
sondern auch gänzlich Wehrlose niedermachen lässt.
Ein eigenthümlicher Zug der Massai ist ihre Frömmigkeit und das
feste Vertrauen, welches sie Ng a i, dem Ueberirdischen, Gott,
entgegenbringen. Das Ngai wirklich als Gott aufzufassen ist
erscheint zweifellos, und wenn Thomson anführt, dass die Massai
beim Anblick von etwas ihnen Ungewöhnlichem, z. B. einer Lampe,
»Ngai« rufen, so ist darin ebensowenig etwas verwunderliches wie
wenn der Mohammedaner im gleichem Falle »Alah« ruft. Der Massai
will damit keineswegs sagen, dass die Lampe Ngai sei, sondern nur
seinem Erstaunen über etwas für ihn so Uebernatürliches Ausdruck
geben. Ngai hat seinen Sitz in der Höhe, im Himmel, er wird stehend
mit erhobenen Händen, in welchen man Grasbüschel hält und mit
dem Ruf »Ngaieh!« verehrt. Vor jedem Kriegszug, sowie überhaupt
in allen Lebenslagen kann man die Massai derart beten sehen.
Die Sterne, welche Nachts am Himmel blinken sind Augen
Ngai's, der auf die schlummernden Massai herabblickt. Eine
Sternschnuppe bedeutet den Tod eines Menschen; dann flehen sie,
dass kein Massai sondern ein Feind, ein Mangati sterben möge. Die
Massai sind überhaupt das auserwählte Volk Ngai's, ihnen hat er alle
Rinder zugewiesen und sie üben nur ihr Recht aus, wenn sie den
Feinden die ihrigen wegnehmen. — Merkwürdig ist die Auffassung
der Jahreszeiten. Während der grossen Regenzeit, ngokwa (den
Mvuli der Swahíli), wo die Rinder fett werden, freut sich Gott und
vergiesst Freudethränen. Im Blitz zeigt er seinen furchtbaren Blick,
der Donner ist sein Freudengeschrei über das was er gesehen, dann
folgt der befruchtende Regen. In der kleinen Regenzeit, ndumure
(den Masika der Swahíli), wo die Rinder abmagern, weint Ngai vor
Schmerz über die Gleichgültigkeit der Massai. Je länger die Masika
dauert, desto grösser ist seine Trauer, die sie durch Gebet zu
besänftigen suchen.
Die Sonne betrachten die Massai als einen Mann der auf einem
Wege gegen Westen zieht, jedoch im Osten wohnt. Im Westen
taucht er in eine Höhle und besucht seine Frau, den Mond. Dann eilt
er auf hoher Brücke, den Blicken unsichtbar, wieder nach Osten, um
Morgens wieder gegen Westen zu ziehen, wohin ihm der Mond
schon vorausgeeilt ist. Als vornehmster Stern gilt Kilekeen, der
Morgenstern.
Ein Leben nach dem Tode wird von allen Massai geleugnet. Die
bösen Wald- und Felsengeister, die durch Bestreuen ihrer Wohnsitze
mit Gras oder Steinen versöhnt werden, gelten nicht wie bei den
Bantu als Geister der Verstorbenen, sondern als Kinder Gottes, der
jedoch selbst gut ist. Dieser Gruppe gehört wohl auch der Geist
Neiterkop an, den Krapf erwähnt, von dem ich jedoch nichts erfuhr.

Den Verkehr mit Ngai vermittelt der L a i b o n, Zauberer, der
überhaupt die bedeutendste Rolle im Distrikt spielt. Sein Schüler und
Nachfolger ist der Leigwenan, der Anführer der jungen Krieger, der,
wenn er über mehrere Kraals steht, Leitunu genannt wird. Der
Laibon macht die Kriegsmedizin und weissagt aus Ziegendärmen,
auch verabreicht er Heilmittel und sucht Ngai zu veranlassen die
Regen günstig einzutheilen. Vor und nach jedem Kriegszug erhält er
von den Kriegern Rinder. Der Laibon geniesst sein Leben lang nur
Elmoran-Kost und Honigwein. Er hat Weiber, besucht sie jedoch nur
insgeheim, seine Hütte darf kein Weib betreten. Manche Laibons
sollen verschiedene Kunststücke machen, sich mit Speeren
durchbohren u. s. w. Ein verstorbener Laibon wird im Gegensatze
zum Allgemeingebrauch begraben; das Grab, das mit grossen
Steinen bedeckt wird, bewacht der Stamm drei Monate lang.
Der oberste Laibon, gewissermaassen ein Massai-Papst, ist der
Mb a t y a n, der stets westlich vom Kilimanjaro residirt. An diesen
glauben alle Massai, nicht aber die Mbaravui (Wakuavi). Der
Mbatyan ist stets einäugig, der Vater pflegt dem Sohn ein Auge
auszuschlagen, um ihn zu der Würde geeignet zu machen. Alle
Massai bringen ihm Rinder, erflehen seine Fürbitte bei Kriegszügen
und betrachten ihn mit grosser Ehrfurcht.
Zeitpunkt und Richtung der Kr ie g szü g e werden vom Laibon
und Leigwenan bestimmt; letzterer ist der Anführer. An den Zügen
betheiligen sich Elmoran und meist auch eine Anzahl Elmoruo. Eine
Rinderheerde wird als Proviant mitgetrieben und im Dauermarsch
werden ungeheure Strecken zurückgelegt. Immerhin hätten die
Massai wohl niemals solche Erfolge erringen können, wenn sie es
nicht verstanden hätten, unter den sesshaften Völkern selbst
Bundesgenossen zu erwerben, die ihnen Zuflucht gaben und sie mit
Führern versahen. Für Unyamwesi und Usukuma spielte Mtinginya
von Usongo diese Rolle.
Der Angriff des Massai erfolgt meist überraschend und sehr
energisch. Besonders wo Heerden unter wenigen Hirten weiden
gelingt es ihnen fast immer sie zu erbeuten. Aengstliche
Eingeborene wagen dann nicht die Räuber zu verfolgen, muthige
dagegen, wie die Wambugwe, setzen ihnen nach und jagen ihnen
das Vieh wieder ab. Mit der glücklich erworbenen Beute ziehen die
Massai unter lautem Gesang heimwärts, wobei sie einen Mann
voraussenden, der den glücklichen Verlauf des Raubzuges im Lager
meldet. Die Vertheilung der Beute geschieht noch im freien Felde
und dabei kommt es nicht selten zu blutigen Schlägereien. Im Lager
findet ein Siegesfest statt, bei welchem die Krieger mit den Nditos im
Gänsemarsch, singend tanzen.
Sk la ve r e i ist den Massai unbekannt, doch machen sie nicht
selten Knaben und Mädchen zu Kriegsgefangenen und nehmen sie
in den Stamm auf. Diese Sitte, sowie die leichte Zugänglichkeit der
Massaiweiber Karawanenleuten und wohl auch anderen
Eingeborenen gegenüber, führt den Massai viel fremdes Blut zu. Das
S tr e i fg e b i e t der Massai umfasst ein ungeheures Gebiet. Im Osten
reicht es an die Küste, im Süden nach Mpwapwa und Ugogo, im
Westen zum Victoria-Nyansa und bis zur Grenze von Usinja, über
ganz Unyamwesi und ins südliche Uha, wo sie vor mehreren Jahren
mit den Wangoni (Watuta) zusammenstiessen. In Ugogo und
Unyamwesi nennt man sie Wahumba, in Usukuma Wassekera,
offenbar nach der Massai-Landschaft Ndassekera. Sie selbst haben
für alle Länder ihre eigene Nomenklatur, so nennen sie Umbugwe
Ltoroto, Unguu Kimalando und kennen nur ihre eigenen
Bezeichnungen.
Als Friedenszeichen pflegen die Massai ein Büschel Gras zu
überreichen, welches sie vorher bespeien. Das Bespeien spielt
überhaupt eine grosse Rolle, so musste ich alle kleinen Geschenke
an Glasperlen u. s. w., die ich ihnen machte, vorher bespeien. Der
Gruss geschieht durch Reichen der Hand, wozu man »Sowai!« ruft,
der Gegrüsste antwortet »Evá!«
In Streitfällen entscheidet ein Gericht von Greisen. Mörder
werden getödtet, wenn eine Sühne von 10 Rindern von den
Verwandten des Getödteten abgelehnt wird. Diebstahl im Stamme
selbst kommt fast niemals vor. Lügen sind häufig, gelten jedoch als
grosser Fehler.
Indem wir damit die Schilderung der Massai schliessen, muss
hervorgehoben werden, dass dieselbe in vielen Zügen heute nicht
mehr giltig ist, sondern sich auf den Zeitraum vor 1891 bezieht. In
diesem Jahre verheerte nämlich die Vi e h se u ch e, eine
Lungenkrankheit, die in ganz Ost-Afrika wüthete, die Heerden der
Massai in furchtbarer Weise. Während die sesshaften Völker,
welchen als Nahrungsmittel die Produkte des Ackerbaus blieben,
sich durch Aufzucht der wenigen verschonten Thiere erholen
konnten, zehrten die Massai auch diese auf, so dass sie heute
thatsächlich fast gar keine Rinder mehr besitzen. In der ersten Zeit
gingen kolossale Mengen von Massai, wohl zwei Drittel des ganzen
Stammes, zu Grunde. Die Krieger konnten sich durch Jagd und
kleine Diebstähle noch eher durchbringen, die Weiber, Kinder und
Greise waren aber dem Elend völlig preisgegeben.
Zu Skeletten abgemagert wankten sie durch die Steppen, vom
Honig der Waldbienen und ekelhaftem Aas sich nährend. Alle
kriegerischen Unternehmungen schlugen fehl, die Elmoran wurden
einfach zurückgeworfen und kehrten oft gar nicht heim, sondern
verhungerten unterwegs. Nur in wenigen Gebieten halten sich noch
Kraals durch Kleinvieh und Eselzucht, sowie durch die Jagd, sonst
sind weite Striche verlassen und die Massai leben als Bettler bei den
Ackerbauern der Umgebung. Dass sie dabei an Einhaltung der alten
Speisegesetze nicht mehr denken, dass der Elmoran ebenso
Getreide und Jagdwild verzehrt wie ein anderer, ist
selbstverständlich.
Viele Ackerbauer, wie die Wambugwe und ihre Nachbarn, wollen
die alten Feinde selbst im Elend nicht kennen und machen jeden
Massai nieder. In Usukuma, Schaschi, in Irangi, Unguu und
Usagara, sowie in der Kilimanjaro-Gegend finden sie jedoch Zuflucht
und Almosen an Nahrungsmitteln. Denn der Massai bleibt stets ein
Bettler, niemals wird es ihm einfallen zum Spaten zu greifen und
seine Gastfreunde in der Arbeit zu unterstützen. Wo er dazu
gezwungen wird, geht er entweder zu Grunde oder er läuft wieder
davon — in die Steppe.
Der Verlauf dieser Seuche hat überhaupt den Beweis geliefert,
dass die Massai, trotz ihres intelligenten und einnehmenden
Aeusseren, doch absolut nicht bildungsfähig und zum Untergang
bestimmt sind. Ich selbst hatte eine Anzahl Massai als Viehhirten
Monate hindurch bei der Expedition, die sich rasch von ihrem
Hunger erholten. Sie ertrugen Klimawechsel sehr schlecht, der
jedesmal mehrere Opfer erforderte. Zu irgend welcher anderen
Beschäftigung als Viehtreiber waren sie gänzlich unfähig. Trotzdem
sie wenig unter einander, sondern meist mit Trägern verkehrten, die
nur Kiswahíli sprachen, hat doch kein Einziger auch nur nothdürftig
Welcome to our website – the ideal destination for book lovers and
knowledge seekers. With a mission to inspire endlessly, we offer a
vast collection of books, ranging from classic literary works to
specialized publications, self-development books, and children's
literature. Each book is a new journey of discovery, expanding
knowledge and enriching the soul of the reade

Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.

Let us accompany you on the journey of exploring knowledge and


personal growth!

textbookfull.com

You might also like