About Drivers
Drivers are simply extensions to features that are managed by the Manager Pattern. If we have a
UploadManager then we might also create a UploadDiskDriver and a UploadS3Driver which will be able to upload to both the file system (disk) and Amazon S3. In the future if we have to upload to Microsoft Azure or Google Cloud Storage then we simply create new drivers like UploadAzureDriver and UploadGoogleDriver which are very simple to create. Drivers can be as small as a single method or have dozens of methods. The Manager Pattern makes it dead simple to expand the functionality of a Manager and add capabilities to Masonite's features.Let's go ahead and create a simple driver which is already in the framework called the
UploadDiskDriver.If you are creating a driver it can live wherever you like but if you are creating it for Masonite core then it should live inside
masonite/drivers. For our UploadDiskDriver we will create the file: masonite/drivers/UploadDiskDriver.py.We should make a class that looks something like:
from masonite.contracts import UploadContract
class UploadDiskDriver(UploadContract):
pass
In order to ensure that all drivers follow the same structure, we can use Contracts. Contracts are essentially interfaces if you are coming from other programming languages. They make sure that the classes they inherit into have the minimum methods necessary in order to be accepted as a driver. If it does not meet the minumum methods necessary then you will keep hitting exceptions every time you tried to run your code.
For our specific driver we should inherit from the
UploadContract:from masonite.contracts import UploadContract
class UploadDiskDriver(UploadContract):
pass
Simple enough, now we can start coding what our API looks like. In the endgame, we want developers to do something like this from their controllers:
from masonite import Upload
def show(self, upload: Upload):
upload.store(request().input('file'))
So we can go ahead and make a
store method.from masonite.contracts import UploadContract
class UploadDiskDriver(UploadContract):
def store(self, fileitem, location=None):
pass
Ok great. Now here is the important part. Our Manager for this driver (which is the
UploadManager) will resolve the constructor of this driver. This basically means that anything we put in our constructor will be automatically injected into this driver. So for our purposes of this driver, we will need the storage and the application configuration.from masonite.contracts import UploadContract
from config import storage, application
class UploadDiskDriver(UploadContract):
def __init__(self, cls: SomeClass):
self.cls = cls
self.config = storage
self.appconfig = application
def store(self, fileitem, location=None):
pass
Great. If you're confused about how the dependency injection Service Container works then read the Service Container documentation.
Now that we have our configuration we need injected into our class, we can go ahead and build out the
store() method:from masonite.contracts import UploadContract
from config import storage, application
class UploadDiskDriver(UploadContract):
def __init__(self):
self.config = storage
self.appconfig = application
def store(self, fileitem, location=None):
filename = os.path.basename(fileitem.filename)
if not location:
location = self.config.DRIVERS['disk']['location']
location += '/'
open(location + filename, 'wb').write(fileitem.file.read())
return location + filename
Ok great! You can see that our
store() method simply takes the file and write the contents of the fileitem to the disk.So now that our driver is created, we can tell our Manager about it. Learn how to create managers under the About Managers documentation. Our manager will know of all drivers that are inside the Service Container. We can create a new service provider which we can use to register classes into our container. Here is an example of what the
UploadProvider will look like:from masonite.provider import ServiceProvider
from masonite.managers import UploadManager
from masonite.drivers import UploadDiskDriver
from config import storage
class UploadProvider(ServiceProvider):
wsgi = False
def register(self):
self.app.bind('StorageConfig', storage)
self.app.bind('UploadDiskDriver', UploadDiskDriver)
self.app.bind('UploadManager', UploadManager(self.app))
def boot(self, manager: UploadManager):
self.app.bind('Upload', manager.driver(storage.DRIVER))
Notice how we set our storage configuration in the container, binded our drivers and then binded our Manager. Again, our manager will be able to find all our
UploadXDrivers that are loaded into the container. So if we set the DRIVER inside our configuration file to google, our manager will look for a UploadGoogleDriver inside our container. Read more about Managers in the About Managers documentation.That's it! Drivers are extremely simple and most drivers you create will be a simple class with a single method or two.
Last modified 5yr ago