These are the slide for my talk about Abstract Filesystems I did at Laracon 2014.

1. FILESYSTEM
ABSTRACTION
WITH FLYSYSTEM
By @FrankDeJonge

2. WHAT IS FILESYSTEM ABSTRACTION?
Bridging the gap between filesystems so the storage engine
becomes an implementation detail.

3. FILESYSTEM
ABSTRACTION 101
What are filesystems?
How do we use filesystems?
Moving to remote filesystems.
Abstraction saves the day.

4. WHAT IS A FILESYSTEM?
LOGIC & STRUCTURE

5. WHAT IS A FILESYSTEM?
Logic to structure and organize pieces of data in a storage
system.

6. WHAT'S IN A FILESYSTEM?
Files
Directories
Metadata

7. COMMON METADATA
Location / Path
Timestamps
Permissions / Ownership

8. FILE SPECIFIC
Mime-type
File size
Contents

9. DERIVED INFORMATION / PATHINFO():
Filename
Basename
Extension
Dirname
Mime-type

10. FILESYSTEM STRUCTURE

11. STRUCTURE TYPES:
Nested or Linear
 src/
 Filesystem.php
 AdapterInterface.php
 tests/
 Filesystem.php
 AdapterInterface.php
 src/Filesystem.php
 src/AdapterInterface.php
 tests/Filesystem.php
 tests/AdapterInterface.php

12. NESTED FILESYSTEMS
Are the most common
Have directories
which have files and more directories
... which have more files and directories
... which have more files and directories.
We're really used to this structure.

13. LINEAR FILESYSTEM
Are like key/value stores
do have files, of course
require a different approach
don't really have directories.

14. DIRECTORIES ARE A MYTH

15. WHAT CAN WE DO WITH
A FILESYSTEM?
Several operations:
write
read
update
delete
move / rename
copy
list
inspect

16. HANDLING FILESYSTEMS WITH PHP, A WORLD
OF HURT.

17. In vanilla PHP for local files:
$result = file_put_contents($location, $contents);
$contents = file_get_contents($location);
unlink($location);
$timestamp = mtime($location);
$mimetype = mime_content_type($location); // DEPRECATED
$mimetype = (new Finfo(FILEINFO_MIME_TYPE))->file($location);

18. LISTING FILES
glob($location . '/*'); // ?
scandir($location); // ?
readdir(opendir($location)); // ?
array_map('normalize_fileinfo',
iterator_to_array(new DirectoryIterator($location))); // ?
array_map('normalize_fileinfo',
iterator_to_array(new RecursiveIteratorIterator(
new RecursiveDirectoryIterator($location)
))); // ?

19. Memory problems? Use streams:
$resource = fopen($rLocation, 'r+');
$handle = fopen($location, 'w+');
while ( ! feof($resource)) {
fwrite($handle, fread($resource, 1024), 1024);
}
$result = fclose($handle);
fclose($resource);

20. WORKING WITH OTHER
FILESYSTEMS.
BECAUSE REASONS.

21. SOME REASONS WHY:
We want to scale (horizontally).
... so, we want stateless apps.
We don't have to serve files ourselves.
Share files across multiple application.
We want to enable a nice experience to our users which was
not possible otherwise.

22. SOME CONSEQUENCES
We can't use built-in PHP function anymore.
We'll have to start using API's
We'll have to depend on third party code.

23. COMPARING INTEGRATIONS: WRITING FILES
AWS/S3:
$options = [
'Body' => $contents,
'ContentType' => 'plain/text',
'ContentLength' => mb_strlen($contents),
];
$result = $awsClient->putObject($options);
Dropbox:
$result = $dropboxClient->uploadFileFromString(
$location,
$contents,
WriteMode::add());

24. Rackspace:
$result = $rackspaceClient->uploadObject($location, $contents);
WebDAV:
$result = $client->request('PUT', $location, $contents);
FTP:
$stream = tmpfile();
fwrite($stream, $contents);
ftp_fput($connection, $destination, $stream, FTP_BINARY);
fclose($stream);

25. DOWNSIDES
Different API
Support different kinds of input (string vs stream support)
Different results for EVERY operation

26. CHOOSING A FILESYSTEM ...
can create technical dept
can create vendor lock-in
require you to invest in them

27. SOLUTION?
USE AN ABSTRACT
FILESYSTEM.

28. WHAT IS AN ABSTRACT FILESYSTEM?
Logic and structure that enable a generalized API to work with
different filesystems.

29. WHAT DOES A ABSTRACT FILESYSTEM DO?
It bridges the gap between different filesystem
implementations/packages and normalizes responses.

30. INTRODUCING:
FLYSYSTEM
MANY FILESYSTEMS, ONE API

31. FLYSYSTEM IS:
A filesystem abstraction layer
Like a DBAL for files.
Like illuminate/filesystem on steroids.

32. PACKED WITH SUPERPOWERS:
Well tested code
Easy API
Cachable metadata
Easy stream handling

33. FIRST LOOK AT FLYSYSTEM
use LeagueFlysystemAdapterLocal;
$adapter = new Local(__DIR__.'/path/to/dir');
$fs = new Filesystem($adapter);
BASIC FS OPERATIONS:
$fs->write($location, $contents);
$fs->read($location);
$fs->update($location, $contents);
$fs->listContents($location, $recursive);
$fs->delete($location);
$fs->getTimestamp($location);

34. USING AWS S3
use LeagueFlysystemAdapterAwsS3;
$adapter = new AwsS3($client, 'bucket-name');
$fs = new Filesystem($adapter);
BASIC FS OPERATIONS:
$fs->write($location, $contents);
$fs->read($location);
$fs->update($location, $contents);
$fs->listContents($location, $recursive);
$fs->delete($location);
$fs->getTimestamp($location);

35. USING FTP
use LeagueFlysystemAdapterFtp;
$adapter = new Ftp($ftpSettings);
$fs = new Filesystem($adapter);
BASIC FS OPERATIONS:
$fs->write($location, $contents);
$fs->read($location);
$fs->update($location, $contents);
$fs->listContents($location, $recursive);
$fs->delete($location);
$fs->getTimestamp($location);

36. MANY FILESYSTEMS
ONE API

37. FLYSYSTEM AND STREAMS:
$resource = $dropbox->readStream($location);
$awsS3->writeStream($destination, $resource);

38. FLYSYSTEM IS A GATEWAY DRUG FOR...
... DRY code
... centralized problem domain handling
... easily testable FS interactions
... reduced technical dept
... lower development costs
... having less to learn.

39. TESTING FILESYSTEM INTERACTIONS
USING FLYSYSTEM
Becomes easier.
Becomes more reliable.
Might even become fun again.

40. DEPENDING ON FLYSYSTEM
class Author
{
public function __construct(FilesystemInterface $filesystem)
{
$this->filesystem = $filesystem;
}
public function getBio()
{
return $this->filesystem->read($this->getBioLocation());
}
}

41. TESTING THE DEPENDANT CODE
public function testGetBio()
{
$expected = 'Some Bio';
$fsMock = Mockery::mock('LeagueFlysystemFilesystemInterface');
$fsMock->shouldReceive('read')
->with('james-doe-bio.txt')
->andReturn($expected);
$autor = new Author($fsMock);
$this->assertEquals($expected, $author->getBio());
}
BONUS: this makes tests run super fast because you don't have
to wait for blocking filesystem operations (slow).

42. IMPROVED STABILITY OF DEPENDANT CODE
Class should have one reason to change
... changing filesystems isn't one of them.
Most code shouldn't have to care where files are stored.
Flysystem enables classes to be unaware of this.

43. OPENING UP TO NEW POSSIBILITIES
Using Dropbox for uploads
Ease development by deferring filesystem choice.
Painless pivots during application lifecycle.
Nice to build a package on.

44. FLYSYSTEM INTEGRATIONS
Laravel Integration:
https://github.com/GrahamCampbell/Laravel-Flysystem
Symfony Bundle:
https://github.com/1up-lab/OneupFlysystemBundle
Backup Manager:
https://github.com/heybigname/backup-manager
Cartalyst Media:
http://cartalyst.com

45. CRAZY FLYSYSTEM ADAPTERS
NOTE: some might be urban myths, I haven't seen them all.
Flickr
Youtube
Reddit

46. THE LEAGUE OF EXTRAORDINARY PACKAGES
HTTP://GITHUB.COM/THEPHPLEAGUE/FLYSYSTEM

47. THANKS FOR LISTENING!
Find me on twitter @FrankDeJonge