Setup CloudFront distribution with SSL and pakaging.

Author: erankitcs

01-webotron/Pipfile

@@ -9,6 +9,7 @@ pycodestyle = "*"
 pylint = "*"
 pydocstyle = "*"
 pyflakes = "*"
+setuptools = "*"
 
 [packages]
 boto3 = "*"

01-webotron/Pipfile.lock

@@ -0,0 +1,20 @@
+from setuptools import setup
+
+setup(
+    name='webotron-20',
+    version='0.1',
+    author='Ankit K Singh',
+    author_email='er.ankit.cs@gmail.com',
+    description='Webotron 20 is a tool to deploy static website to AWS.',
+    license='GPLv3+',
+    packages=['webotron'],
+    url='https://github.com/erankitcs/automating-aws-with-python',
+    install_requires=[
+        'click',
+        'boto3'
+    ],
+    entry_points='''
+        [console_scripts]
+        webotron=webotron.webotron:cli
+    '''
+)

01-webotron/setup.py

@@ -6,13 +6,14 @@
 import mimetypes
 import boto3
 from botocore.exceptions import ClientError
-import util
+from webotron import util
 from hashlib import md5
 from functools import reduce
 
 
 class BucketManager:
     """Manage an S3 Bucket."""
+
     CHUNK_SIZE = 8388608
 
     def __init__(self, session):
@@ -104,24 +105,25 @@ def configure_website(self, bucket):
         )
 
     def load_manifest(self, bucket):
-        """Load manifest for caching purpose"""
+        """Load manifest for caching purpose."""
         paginator = self.s3.meta.client.get_paginator('list_objects_v2')
         for page in paginator.paginate(Bucket=bucket.name):
-            for obj in page.get('Contents',[]):
+            for obj in page.get('Contents', []):
                 self.manifest[obj['Key']] = obj['ETag']
+
     @staticmethod
     def hash_data(data):
-        """Generate md5 hash for data"""
-        hash=md5()
+        """Generate md5 hash for data."""
+        hash = md5()
         hash.update(data)
         return hash
 
     def gen_etag(self, path):
-        """Generate etag for file"""
+        """Generate etag for file."""
         hashes = []
-        with open(path,'rb') as f:
+        with open(path, 'rb') as f:
             while True:
-                data=f.read(self.CHUNK_SIZE)
+                data = f.read(self.CHUNK_SIZE)
                 if not data:
                     break
                 hashes.append(self.hash_data(data))
@@ -132,21 +134,19 @@ def gen_etag(self, path):
         else:
             hash = self.hash_data(
                                     reduce(
-                                        lambda x,y: x+y,
+                                        lambda x, y: x+y,
                                         (
                                             h.digest() for h in hashes
                                         )
                                     )
                                 )
-            return '"{}-{}"'.format(hash.hexdigest(),len(hashes))
-
-
+            return '"{}-{}"'.format(hash.hexdigest(), len(hashes))
 
     def upload_file(self, bucket, path, key):
         """Upload path to S3 bucket with key."""
         content_type = mimetypes.guess_type(key)[0] or 'text/plain'
         etag = self.gen_etag(path)
-        if self.manifest.get(key,'') == etag:
+        if self.manifest.get(key, '') == etag:
             print("Skipping {}, etag match".format(key))
             return
         return bucket.upload_file(
@@ -158,21 +158,56 @@ def upload_file(self, bucket, path, key):
                 Config=self.transfer_config
             )
 
+    def delete_files(self, bucket, objects):
+        """Delete files from given bucket."""
+        response = bucket.delete_objects(
+            Delete={
+                    'Objects': objects
+                },
+            RequestPayer='Webotron'
+            )
+        print(response)
+        for item in response['Deleted']:
+            print(
+                'File has been successfully deleted : {}'.format(item['Key'])
+            )
+        if 'Errors' in response.keys():
+            for item in response['Errors']:
+                print(
+                    'Error in deleteFile : {} ,'
+                    'ErrorCode: {} , ErrorMsg: {}'.format(
+                        item['Key'], item['Code'], item['Message']
+                    )
+                )
+
     def sync(self, pathname, bucket_name):
         """Sync contents of path to bucket."""
         bucket = self.s3.Bucket(bucket_name)
         root = Path(pathname).expanduser().resolve()
         self.load_manifest(bucket)
+        self.file_list_source = []
 
         def handle_directory(target):
             for p in target.iterdir():
                 if p.is_dir():
                     handle_directory(p)
                 if p.is_file():
+                    self.file_list_source.append(
+                        str(p.relative_to(root).as_posix())
+                    )
                     self.upload_file(
                         bucket,
                         str(p),
                         str(p.relative_to(root).as_posix())
                     )
 
+        def handle_bucket(directory_flist, bucket_keylist):
+            files_delete = []
+            for key in bucket_keylist.keys():
+                if key not in directory_flist:
+                    key_dic = {'Key': key}
+                    files_delete.append(key_dic)
+            self.delete_files(bucket, files_delete)
+
         handle_directory(root)
+        handle_bucket(self.file_list_source, self.manifest)