Introduktion
- Nyckelfunktioner
- Exempel
Installation
- Krav
- Valfria Beroenden
Användning
Generatorer
Avancerad Användning
Konfiguration
- Globala Konfigurationsmetoder
Stödriktlinjer
- Gemenskapsdriven Stöd
- Buggar och Prioritering av Funktioner
Licens - MIT Licens

Introduktion

Faker Storage är ett högpresterande PHP-paket designat för att generera och lagra stora volymer av falska datafiler effektivt. Byggt med koncurrency i åtanke, utnyttjar det Swoole eller PCNTL för att generera tusentals filer parallellt, vilket gör det idealisk för belastningstestning, utvecklingsmiljöer och benchmarkning av lagringssystem.

Paketet erbjuder ett flytande API för att generera olika filtyper inklusive bilder (PNG, JPG, GIF, BMP, WEBP, AVIF), textfiler, CSV-filer, binär data och RFC822-kompatibla e-postmeddelanden. Varje generator producerar deterministisk output när den sås, vilket säkerställer reproducerbar testdata över miljöer.

Nyckelfunktioner

Högpresterande Concurrency: Automatisk val mellan Swoole (korutiner) och PCNTL (processforking) för parallell filgenerering
Flera Filgeneratorer: Inbyggt stöd för bilder, text, CSV, binär och e-postfiler
Deterministisk Output: Sådd-baserad generation säkerställer reproducerbara resultat
Flexibel Lagring: Fungerar med vilken League Flysystem-adapter som helst (lokalt, S3, etc.)
Anpassningsbar Filnamngivning: Closure-baserad namngivning med full kontroll
Bildstöd: Flera format med konfigurerbara dimensioner och kompression
E-postgenerering: RFC822-kompatibla e-postmeddelanden med bilagor och MIME-stöd

Exempel

use DefectiveCode\Faker\Faker;
use League\Flysystem\Filesystem;
use DefectiveCode\Faker\Generators\Png;
use League\Flysystem\Local\LocalFilesystemAdapter;
 
// Generera 1000 PNG-bilder med 10 samtidiga arbetare
Faker::make(Png::class)
    ->width(800, 1920)
    ->height(600, 1080)
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/path/to/storage')))
    ->basePath('images')
    ->count(1000)
    ->concurrency(10)
    ->seed(42)
    ->generate();
 
// Generera CSV-filer
use DefectiveCode\Faker\Generators\Csv;
 
Faker::make(Csv::class)
    ->columns(5, 10)
    ->rows(100, 500)
    ->delimiter(',')
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/path/to/storage')))
    ->count(50)
    ->generate();
 
// Generera e-postmeddelanden med bilagor
use DefectiveCode\Faker\Generators\Email;
 
Faker::make(Email::class)
    ->paragraphs(3, 5)
    ->sentences(2, 4)
    ->withAttachment(Png::class, 1, 3)
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/path/to/storage')))
    ->count(100)
    ->generate();

Installation

Installera paketet via Composer:

composer require defectivecode/faker-storage

Krav

PHP >= 8.4
ext-gd (för bildgenerering)
ext-swoole (valfritt, för bättre prestanda)
ext-pcntl (fallback för concurrency)

Valfria Beroenden

För optimal prestanda, installera Swoole-tillägget:

pecl install swoole

Paketet kommer automatiskt att använda Swoole om det är tillgängligt, annars faller det tillbaka till PCNTL.

Användning

Grundläggande Arbetsflöde

Alla generatorer följer samma mönster:

Skapa en Faker-instans med en generator
Konfigurera generatorn (valfritt)
Ställ in lagringsdestination
Konfigurera concurrency och antal
Generera filer

use DefectiveCode\Faker\Faker;
use League\Flysystem\Filesystem;
use DefectiveCode\Faker\Generators\Text;
use League\Flysystem\Local\LocalFilesystemAdapter;
 
Faker::make(Text::class)
    ->paragraphs(5, 10)          // Generator-specifik konfiguration
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/storage')))
    ->basePath('documents')      // Filer kommer att finnas i /storage/documents/
    ->count(100)                 // Generera 100 filer
    ->concurrency(4)             // Använd 4 arbetare
    ->seed(123)                  // För deterministisk output
    ->generate();

Lagringskonfiguration

Använda Flysystem

Faker Storage använder League Flysystem för lagringsabstraktion:

use League\Flysystem\Filesystem;
use League\Flysystem\Local\LocalFilesystemAdapter;
 
// Lokal lagring
$filesystem = new Filesystem(new LocalFilesystemAdapter('/path/to/storage'));
 
Faker::make(Png::class)
    ->toDisk($filesystem)
    ->generate();

AWS S3 Lagring

use Aws\S3\S3Client;
use League\Flysystem\Filesystem;
use League\Flysystem\AwsS3V3\AwsS3V3Adapter;
 
$client = new S3Client([
    'credentials' => [
        'key'    => 'your-key',
        'secret' => 'your-secret',
    ],
    'region' => 'us-east-1',
    'version' => 'latest',
]);
 
$adapter = new AwsS3V3Adapter($client, 'your-bucket-name');
$filesystem = new Filesystem($adapter);
 
Faker::make(Png::class)
    ->toDisk($filesystem)
    ->basePath('uploads/images')
    ->generate();

Diskalternativ

Skicka ytterligare alternativ till filsystemadapteren:

Faker::make(Png::class)
    ->toDisk($filesystem)
    ->diskOptions([
        'visibility' => 'public',
        'ACL' => 'public-read',
        'CacheControl' => 'max-age=31536000',
    ])
    ->generate();

Concurrency Konfiguration

Kontrollera parallell exekvering med concurrency()-metoden:

// Använd 10 arbetstrådar/processer
Faker::make(Png::class)
    ->concurrency(10)
    ->generate();
 
// Swoole-specifik: Ställ in både trådar och korutiner per tråd
Faker::make(Png::class)
    ->concurrency(threads: 4, coroutines: 8)  // 4 arbetare, 8 korutiner var
    ->generate();

Filnamngivning

Standardnamn

Som standard namnges filer med UUID v4:

// Genererar: e7f0a8d3-5c2b-4f9e-8a1d-3b4c5d6e7f8a.png
Faker::make(Png::class)->generate();

Inbyggda Namngeneratorer

use DefectiveCode\Faker\NameGenerator;
 
// UUID-baserad (standard)
NameGenerator::setDefault('uuid'); // Genererar: e7f0a8d3-5c2b-4f9e-8a1d-3b4c5d6e7f8a.png
 
// Sekventiell numrering
NameGenerator::setDefault('sequence'); // Genererar: 1.png, 2.png, 3.png, ...

Anpassad Namngivning

Ge en closure för att anpassa filnamnen:

use DefectiveCode\Faker\NameGenerator;
 
// Anpassad closure
Faker::make(Png::class)
    ->nameGenerator(function (int $seed, int $completedFiles, $generator) {
        return "custom-{$completedFiles}-{$seed}.png";
    })
    ->generate();
 
// Datum-baserad namngivning
Faker::make(Png::class)
    ->nameGenerator(function (int $seed, int $completedFiles, $generator) {
        return date('Y/m/d') . "/image-{$completedFiles}.png";
    })
    ->generate();

Sådd för Reproducerbarhet

Ställ in en sådd för att generera samma filer över körningar:

Faker::make(Png::class)
    ->seed(42)
    ->count(10)
    ->generate();

Varje fil får en unik deterministisk sådd härledd från bas-sådden och filens index.

Generatorer

Bildgeneratorer

Alla bildgeneratorer stödjer dimension- och kvalitetskonfiguration.

PNG

use DefectiveCode\Faker\Generators\Png;
 
Faker::make(Png::class)
    ->width(800, 1920)          // Slumptal mellan 800-1920px
    ->height(600, 1080)         // Slumptal mellan 600-1080px
    ->withAlpha(true)           // Aktivera alfa/transparenskanal
    ->grid(5)                   // Valfritt: Generera 5x5 symmetrisk mönster
    ->toDisk($filesystem)
    ->generate();

JPG

use DefectiveCode\Faker\Generators\Jpg;
 
Faker::make(Jpg::class)
    ->width(800, 1920)          // Slumptal mellan 800-1920px
    ->height(600, 1080)         // Slumptal mellan 600-1080px
    ->grid(5)                   // Valfritt: Generera 5x5 symmetrisk mönster
    ->toDisk($filesystem)
    ->generate();

GIF

use DefectiveCode\Faker\Generators\Gif;
 
Faker::make(Gif::class)
    ->width(800, 1920)          // Slumptal mellan 800-1920px
    ->height(600, 1080)         // Slumptal mellan 600-1080px
    ->withAlpha(true)           // Aktivera alfa/transparenskanal
    ->grid(5)                   // Valfritt: Generera 5x5 symmetrisk mönster
    ->toDisk($filesystem)
    ->generate();

BMP

use DefectiveCode\Faker\Generators\Bmp;
 
Faker::make(Bmp::class)
    ->width(800, 1920)          // Slumptal mellan 800-1920px
    ->height(600, 1080)         // Slumptal mellan 600-1080px
    ->grid(5)                   // Valfritt: Generera 5x5 symmetrisk mönster
    ->toDisk($filesystem)
    ->generate();

WEBP

use DefectiveCode\Faker\Generators\Webp;
 
Faker::make(Webp::class)
    ->width(800, 1920)          // Slumptal mellan 800-1920px
    ->height(600, 1080)         // Slumptal mellan 600-1080px
    ->withAlpha(true)           // Aktivera alfa/transparenskanal
    ->grid(5)                   // Valfritt: Generera 5x5 symmetrisk mönster
    ->toDisk($filesystem)
    ->generate();

AVIF

use DefectiveCode\Faker\Generators\Avif;
 
Faker::make(Avif::class)
    ->width(800, 1920)          // Slumptal mellan 800-1920px
    ->height(600, 1080)         // Slumptal mellan 600-1080px
    ->withAlpha(true)           // Aktivera alfa/transparenskanal
    ->grid(5)                   // Valfritt: Generera 5x5 symmetrisk mönster
    ->toDisk($filesystem)
    ->generate();

Slumptalsbild

Genererar ett slumpmässigt bildformat:

use DefectiveCode\Faker\Generators\RandomImage;
 
Faker::make(RandomImage::class)
    ->width(800, 1920)
    ->height(600, 1080)
    ->withAlpha(false)          // Slumptal från: AVIF, BMP, GIF, JPEG, PNG, WEBP
    ->toDisk($filesystem)
    ->generate();
 
Faker::make(RandomImage::class)
    ->width(800, 1920)
    ->height(600, 1080)
    ->withAlpha(true)           // Slumptal från: AVIF, GIF, PNG, WEBP
    ->toDisk($filesystem)
    ->generate();

Textgenerator

Generera enkla textfiler med stycken:

use DefectiveCode\Faker\Generators\Text;
 
Faker::make(Text::class)
    ->paragraphs(5, 10)         // 5-10 stycken per fil
    ->sentences(3, 6)           // 3-6 meningar per stycke
    ->toDisk($filesystem)
    ->generate();

Exempel på output:

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 
Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.

CSV-generator

Generera CSV-filer med slumpmässiga data:

use DefectiveCode\Faker\Generators\Csv;
 
Faker::make(Csv::class)
    ->columns(5, 10)            // 5-10 kolumner
    ->rows(100, 500)            // 100-500 rader
    ->delimiter(',')            // Kolumnavgränsare
    ->enclosure('"')            // Fältinramning
    ->escape('\\')              // Flykttecken
    ->eol("\n")                 // Radslut
    ->toDisk($filesystem)
    ->generate();

Exempel på output:

"John Doe","john@example.com","555-1234","New York","Engineer"
"Jane Smith","jane@example.com","555-5678","Los Angeles","Designer"
"Bob Johnson","bob@example.com","555-9012","Chicago","Manager"

Binärgenerator

Generera slumpmässig binär data:

use DefectiveCode\Faker\Generators\Binary;
 
Faker::make(Binary::class)
    ->length(1024, 1048576)     // 1KB - 1MB
    ->toDisk($filesystem)
    ->generate();

E-postgenerator

Generera RFC822-kompatibla e-postfiler:

use DefectiveCode\Faker\Generators\Email;
 
Faker::make(Email::class)
    ->paragraphs(3, 5)          // Stycken i e-postmeddelandets kropp
    ->sentences(2, 4)           // Meningar per stycke
    ->withAttachment(Png::class, 1, 3)  // Lägg till 1-3 PNG-bilagor
    ->toDisk($filesystem)
    ->generate();

E-postrubriker

Genererade e-postmeddelanden inkluderar:

Till: Slumptal och e-post
Från: Slumptal och e-post
Ämne: Slumptalsmening
Datum: Aktuellt tidsstämpl
Meddelande-ID: Deterministiskt ID baserat på sådd

E-post med bilagor

Bifoga filer med hjälp av generator-klassnamn eller instanser:

use DefectiveCode\Faker\Generators\Email;
use DefectiveCode\Faker\Generators\Png;
use DefectiveCode\Faker\Generators\Pdf;
 
Faker::make(Email::class)
    ->withAttachment(Png::class, 1, 3)  // 1-3 PNG-bilagor
    ->generate();
 
// Bifoga med hjälp av den konfigurerade generatorinstansen
$pngGenerator = new Png(Png::getDefaultConfig());
$pngGenerator->width(400, 800)->height(300, 600);
 
Faker::make(Email::class)
    ->withAttachment($pngGenerator, 2, 5)
    ->generate();

Exempel på output:

Till: John Doe <john.doe@example.com>
Från: Jane Smith <jane.smith@example.com>
Ämne: Viktigt möte imorgon
Datum: Fre, 03 Jan 2026 10:30:00 +0000
Meddelande-ID: <3e92e5c2b0d632b3a36fbbb17484b7fe@example.com>
Innehållstyp: multipart/mixed; boundary="----=_Part_123"
 
------=_Part_123
Innehållstyp: text/plain; charset=utf-8
Innehållsöverföringskodning: quoted-printable
 
Lorem ipsum dolor sit amet, consectetur adipiscing elit...
 
------=_Part_123
Innehållstyp: image/png; name="attachment.png"
Innehållsfördelning: attachment; filename="attachment.png"
Innehållsöverföringskodning: base64
 
iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==
------=_Part_123--

Avancerad Användning

Anpassade Generatorer

Skapa egna generatorer genom att implementera Generator-gränssnittet:

use DefectiveCode\Faker\Configs\Config;
use DefectiveCode\Faker\Concerns\SetsSeed;
use DefectiveCode\Faker\Generators\Generator;
use DefectiveCode\Faker\Concerns\PreparesFaker;
 
class MyCustomGenerator implements Generator
{
    use PreparesFaker;
    use SetsSeed;
 
    public function __construct(public Config $config) {}
 
    public static function getDefaultConfig(): Config
    {
        return new MyCustomConfig([
            'contentType' => 'application/x-custom',
            'nameGenerator' => NameGenerator::default('extension'),
        ]);
    }
 
    public function generate(): mixed
    {
        // Din generationslogik här
        $data = $this->faker->randomElement(['foo', 'bar', 'baz']);
 
        $stream = fopen('php://temp', 'w+');
        fwrite($stream, $data);
 
        return $stream;
    }
}
 
// Använd din anpassade generator
Faker::make(MyCustomGenerator::class)
    ->toDisk($filesystem)
    ->generate();

Konfigurationsklasser

Varje generator använder en konfigurationsklass som utökar Config:

use DefectiveCode\Faker\Configs\Config;
 
class MyCustomConfig extends Config
{
    public int $minValue = 1;
    public int $maxValue = 100;
}

Prestandatips

Använd Swoole: Installera Swoole-tillägget för bästa prestanda
Justera Concurrency: Matcha antalet trådar med CPU-kärnor för optimal genomströmning
Batchoperationer: Generera stora batchar istället för flera små körningar
Lagringsplats: Använd snabb lagring (SSD, lokal disk) för temporära filer innan uppladdning
Nätverks-I/O: Vid användning av S3, öka concurrency för att maximera bandbreddsanvändningen

Konfiguration

Globala Konfigurationsmetoder

Dessa metoder är tillgängliga på alla Faker-instanser:

`make(string $generator): Faker`

Skapa en ny Faker-instans med den angivna generatorn:

Faker::make(Png::class)

`toDisk(Filesystem $filesystem): Faker`

Ställ in lagringsdestination (obligatoriskt):

Faker::make(Png::class)
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/storage')))

`basePath(string $basePath): Faker`

Ställ in basvägen inom filsystemet:

Faker::make(Png::class)
    ->basePath('images/uploads')  // Filer lagras i /storage/images/uploads/

`count(int $count): Faker`

Ställ in antalet filer som ska genereras:

Faker::make(Png::class)
    ->count(1000)

`concurrency(int $threads, ?int $coroutines = null): Faker`

Konfigurera parallell exekvering:

// Grundläggande concurrency
Faker::make(Png::class)
    ->concurrency(4)
 
// Swoole-specifik: trådar och korutiner
Faker::make(Png::class)
    ->concurrency(threads: 4, coroutines: 8)

`seed(int $seed): Faker`

Ställ in sådd för deterministisk generation:

Faker::make(Png::class)
    ->seed(42)

`nameGenerator(Closure $generator): Faker`

Anpassa filnamngivning:

Faker::make(Png::class)
    ->nameGenerator(function (int $seed, int $completedFiles, $generator) {
        return "file-{$completedFiles}.png";
    })

`diskOptions(array $diskOptions): Faker`

Skicka alternativ till filsystemadapteren:

Faker::make(Png::class)
    ->diskOptions([
        'visibility' => 'public',
        'ACL' => 'public-read',
    ])

`generate(): void`

Utför filgenerering:

Faker::make(Png::class)->generate();

Stödriktlinjer

Tack för att du valde vårt öppna källkodsprojekt! Vänligen ta ett ögonblick för att titta på dessa stödriktlinjer. De kommer att hjälpa dig att få ut det mesta av vårt projekt.

Gemenskapsdriven Stöd

Vårt öppna källkodsprojekt drivs av vår fantastiska gemenskap. Om du har frågor eller behöver hjälp, är StackOverflow och andra online-resurser dina bästa alternativ.

Buggar och Prioritering av Funktioner

Verkligheten av att hantera ett öppet källkodsprojekt betyder att vi inte kan ta itu med varje rapporterad bugg eller funktionsönskemål omedelbart. Vi prioriterar ärenden i följande ordning:

1. Buggar som Påverkar Våra Betalda Produkter

Buggar som påverkar våra betalda produkter kommer alltid att vara vår högsta prioritet. I vissa fall kan vi endast ta itu med buggar som påverkar oss direkt.

2. Gemenskaps Pull Begärningar

Om du har identifierat en bugg och har en lösning, vänligen skicka in en pull-begäran. Efter ärenden som påverkar våra produkter ger vi näst högsta prioritet till dessa gemenskapsdrivna lösningar. När de har granskats och godkänts, kommer vi att sammanfoga din lösning och kreditera ditt bidrag.

3. Ekonomiskt Stöd

För frågor utanför de nämnda kategorierna kan du välja att finansiera deras lösning. Varje öppen fråga är kopplad till ett beställningsformulär där du kan bidra ekonomiskt. Vi prioriterar dessa frågor baserat på det belopp som anges.

Gemenskapsbidrag

Öppen källkod blomstrar när dess gemenskap är aktiv. Även om du inte åtgärdar buggar, överväg att bidra genom kodförbättringar, dokumentationsuppdateringar, handledningar eller genom att hjälpa andra i gemenskapskanaler. Vi uppmuntrar starkt alla, som en gemenskap, att hjälpa till att stödja arbetet med öppen källkod.

För att upprepa, kommer DefectiveCode att prioritera buggar baserat på hur de påverkar våra betalda produkter, gemenskaps pull-begärningar, och det ekonomiska stöd som erhållits för problem.

Licens - MIT Licens

Härmed beviljas tillstånd, kostnadsfritt, till varje person som erhåller en kopia av denna programvara och tillhörande dokumentationsfiler (”Programvaran”), att hantera Programvaran utan begränsningar, inklusive utan begränsning rätten att använda, kopiera, modifiera, sammanfoga, publicera, distribuera, underlicensiera och/eller sälja kopior av Programvaran, och att tillåta personer som Programvaran tillhandahålls till att göra det, med förbehåll för följande villkor:

Den ovanstående copyrightnotisen och denna tillståndsnotis ska inkluderas i alla kopior eller väsentliga delar av Programvaran.

PROGRAMVARAN TILLHANDAHÅLLS "I BEFINTLIGT SKICK", UTAN NÅGON SOM HELST GARANTI, VARE SIG UTTRYCKLIG ELLER UNDERFÖRSTÅDD, INKLUSIVE MEN INTE BEGRÄNSAT TILL GARANTIER FÖR SÄLJBARHET, LÄMPLIGHET FÖR ETT BESTÄMT ÄNDAMÅL OCH INTE KRÄNKNING. UNDER INGA OMSTÄNIGHETER SKA FÖRFATTARNA ELLER COPYRIGHTINNEHAVARNA ANSVARA FÖR NÅGON FORDRAN, SKADOR ELLER ANNAN ANSVARSSKYLDIGHET, VARE SIG I EN RÄTTSLIG ÅTGÄRD, SKADESTÅND ELLER ANNAT, SOM UPPSTÅR FRÅN, GENOM ELLER I SAMBAND MED PROGRAMVARAN ELLER ANVÄNDNINGEN ELLER ANDRA AFFÄRER I PROGRAMVARAN.

🔗Introduktion

🔗Nyckelfunktioner

🔗Exempel

🔗Installation

🔗Krav

🔗Valfria Beroenden

🔗Användning

🔗Grundläggande Arbetsflöde

🔗Lagringskonfiguration

Använda Flysystem

AWS S3 Lagring

Diskalternativ

🔗Concurrency Konfiguration

🔗Filnamngivning

Standardnamn

Inbyggda Namngeneratorer

Anpassad Namngivning

🔗Sådd för Reproducerbarhet

🔗Generatorer

🔗Bildgeneratorer

PNG

JPG

GIF

BMP

WEBP

AVIF

Slumptalsbild

🔗Textgenerator

🔗CSV-generator

🔗Binärgenerator

🔗E-postgenerator

E-postrubriker

E-post med bilagor

🔗Avancerad Användning

🔗Anpassade Generatorer

🔗Konfigurationsklasser

🔗Prestandatips

🔗Konfiguration

🔗Globala Konfigurationsmetoder

make(string $generator): Faker

toDisk(Filesystem $filesystem): Faker

basePath(string $basePath): Faker

count(int $count): Faker

concurrency(int $threads, ?int $coroutines = null): Faker

seed(int $seed): Faker

nameGenerator(Closure $generator): Faker

diskOptions(array $diskOptions): Faker

generate(): void

🔗Stödriktlinjer

🔗Gemenskapsdriven Stöd

🔗Buggar och Prioritering av Funktioner

1. Buggar som Påverkar Våra Betalda Produkter

2. Gemenskaps Pull Begärningar

3. Ekonomiskt Stöd

Gemenskapsbidrag

🔗Licens - MIT Licens

Introduktion

Nyckelfunktioner

Exempel

Installation

Krav

Valfria Beroenden

Användning

Grundläggande Arbetsflöde

Lagringskonfiguration

Concurrency Konfiguration

Filnamngivning

Sådd för Reproducerbarhet

Generatorer

Bildgeneratorer

Textgenerator

CSV-generator

Binärgenerator

E-postgenerator

Avancerad Användning

Anpassade Generatorer

Konfigurationsklasser

Prestandatips

Konfiguration

Globala Konfigurationsmetoder

`make(string $generator): Faker`

`toDisk(Filesystem $filesystem): Faker`

`basePath(string $basePath): Faker`

`count(int $count): Faker`

`concurrency(int $threads, ?int $coroutines = null): Faker`

`seed(int $seed): Faker`

`nameGenerator(Closure $generator): Faker`

`diskOptions(array $diskOptions): Faker`

`generate(): void`

Stödriktlinjer

Gemenskapsdriven Stöd

Buggar och Prioritering av Funktioner

Licens - MIT Licens