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
UploadGoogleStorage 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
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:
We should make a class that looks something like:
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:
def show(self, Upload):Upload.store(request().input('file'))
So we can go ahead and make a
class UploadDiskDriver: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.
class UploadDiskDriver:def __init__(self, StorageConfig, Application):self.config = StorageConfigself.appconfig = Applicationdef 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
class UploadDiskDriver:def __init__(self, StorageConfig, Application):self.config = StorageConfigself.appconfig = Applicationdef 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 ServiceProviderfrom masonite.managers import UploadManagerfrom masonite.drivers import UploadDiskDriverfrom config import storageclass UploadProvider(ServiceProvider):wsgi = Falsedef register(self):self.app.bind('StorageConfig', storage)self.app.bind('UploadDiskDriver', UploadDiskDriver)self.app.bind('UploadManager', UploadManager(self.app))def boot(self, UploadManager, StorageConfig):self.app.bind('Upload', UploadManager.driver(StorageConfig.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
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.