docker-squash 1.3.0__py3-none-any.whl

docker_squash/v2_image.py

@@ -0,0 +1,425 @@
+import gzip
+import hashlib
+import json
+import os
+import shutil
+from collections import OrderedDict
+from typing import Any, Dict, List, Tuple
+
+from docker_squash.errors import SquashError
+from docker_squash.image import Image
+
+
+class V2Image(Image):
+    FORMAT = "v2"
+
+    def _before_squashing(self):
+        super(V2Image, self)._before_squashing()
+
+        # Read old image manifest file
+        self.old_image_manifest = self._get_manifest()
+        self.log.debug(
+            f"Retrieved manifest {json.dumps(self.old_image_manifest, indent=4)}"
+        )
+
+        # Read old image config file
+        self.old_image_config = self._read_json_file(
+            os.path.join(self.old_image_dir, self.old_image_manifest["Config"])
+        )
+
+        # Read layer paths inside of the tar archive
+        # We split it into layers that needs to be squashed
+        # and layers that needs to be moved as-is
+        self.layer_paths_to_squash: List[str] = []
+        self.layer_paths_to_move: List[str] = []
+        self.layer_paths_to_squash, self.layer_paths_to_move = self._read_layer_paths(
+            self.old_image_config, self.old_image_manifest, self.layers_to_move
+        )
+
+        if self.layer_paths_to_move:
+            self.squash_id = self.layer_paths_to_move[-1]
+
+        self.log.debug(f"Layers paths to squash: {self.layer_paths_to_squash}")
+        self.log.debug(f"Layers paths to move: {self.layer_paths_to_move}")
+
+    def _squash(self) -> str:
+        if self.layer_paths_to_squash:
+            # Prepare the directory
+            os.makedirs(self.squashed_dir)
+            # Merge data layers
+            self._squash_layers(self.layer_paths_to_squash, self.layer_paths_to_move)
+
+        self.diff_ids = self._generate_diff_ids()
+        self.chain_ids = self._generate_chain_ids(self.diff_ids)
+
+        if self.layer_paths_to_squash:
+            # Must run after the diff ID is computed: the diff ID is the digest
+            # of the uncompressed tar.
+            self._compress_squashed_layer()
+
+        metadata = self._generate_image_metadata()
+        image_id = self._write_image_metadata(metadata)
+
+        layer_path_id = None
+
+        if self.layer_paths_to_squash:
+            # Compute layer id to use to name the directory where
+            # we store the layer data inside of the tar archive
+            layer_path_id = self._generate_squashed_layer_path_id()
+
+            if self.oci_format:
+                old_layer_path = self.old_image_manifest["Config"]
+            else:
+                if self.layer_paths_to_squash[0]:
+                    old_layer_path = self.layer_paths_to_squash[0]
+                else:
+                    old_layer_path = layer_path_id
+                old_layer_path = os.path.join(old_layer_path, "json")
+
+            metadata = self._generate_last_layer_metadata(layer_path_id, old_layer_path)
+            self._write_squashed_layer_metadata(metadata)
+
+            # Write version file to the squashed layer
+            # Even Docker doesn't know why it's needed...
+            self._write_version_file(self.squashed_dir)
+
+            # Move the temporary squashed layer directory to the correct one
+            shutil.move(
+                self.squashed_dir, os.path.join(self.new_image_dir, layer_path_id)
+            )
+
+        manifest = self._generate_manifest_metadata(
+            image_id,
+            self.image_name,
+            self.image_tag,
+            self.old_image_manifest,
+            self.layer_paths_to_move,
+            layer_path_id,
+        )
+
+        self._write_manifest_metadata(manifest)
+
+        repository_image_id = manifest[0]["Layers"][-1].split("/")[0]
+
+        # Move all the layers that should be untouched
+        self._move_layers(
+            self.layer_paths_to_move, self.old_image_dir, self.new_image_dir
+        )
+
+        repositories_file = os.path.join(self.new_image_dir, "repositories")
+        self._generate_repositories_json(
+            repositories_file, repository_image_id, self.image_name, self.image_tag
+        )
+
+        return image_id
+
+    def _write_image_metadata(self, metadata):
+        # Create JSON from the metadata
+        # Docker adds new line at the end
+        json_metadata, image_id = self._dump_json(metadata, True)
+        image_metadata_file = os.path.join(self.new_image_dir, "%s.json" % image_id)
+
+        self._write_json_metadata(json_metadata, image_metadata_file)
+
+        return image_id
+
+    def _write_squashed_layer_metadata(self, metadata):
+        layer_metadata_file = os.path.join(self.squashed_dir, "json")
+        json_metadata = self._dump_json(metadata)[0]
+
+        self._write_json_metadata(json_metadata, layer_metadata_file)
+
+    def _write_manifest_metadata(self, manifest):
+        manifest_file = os.path.join(self.new_image_dir, "manifest.json")
+        json_manifest = self._dump_json(manifest, True)[0]
+
+        self._write_json_metadata(json_manifest, manifest_file)
+
+    def _generate_manifest_metadata(
+        self,
+        image_id,
+        image_name,
+        image_tag,
+        old_image_manifest,
+        layer_paths_to_move,
+        layer_path_id=None,
+    ):
+        manifest: Dict[str, Any] = OrderedDict()
+        manifest["Config"] = "%s.json" % image_id
+
+        if image_name and image_tag:
+            manifest["RepoTags"] = ["%s:%s" % (image_name, image_tag)]
+
+        manifest["Layers"] = old_image_manifest["Layers"][: len(layer_paths_to_move)]
+
+        if layer_path_id:
+            manifest["Layers"].append("%s/layer.tar" % layer_path_id)
+
+        return [manifest]
+
+    def _read_json_file(self, json_file):
+        """Helper function to read JSON file as OrderedDict"""
+
+        self.log.debug(f"Reading '{json_file}' JSON file...")
+
+        with open(json_file, "r") as f:
+            return json.load(f, object_pairs_hook=OrderedDict)
+
+    def _read_layer_paths(
+        self, old_image_config, old_image_manifest, layers_to_move: List[str]
+    ) -> Tuple[List[str], List[str]]:
+        """
+        In case of v2 format, layer id's are not the same as the id's
+        used in the exported tar archive to name directories for layers.
+        These id's can be found in the configuration files saved with
+        the image - we need to read them.
+        """
+
+        # In manifest.json we do not have listed all layers
+        # but only layers that do contain some data.
+        current_manifest_layer = 0
+
+        layer_paths_to_move = []
+        layer_paths_to_squash = []
+
+        # Iterate over image history, from base image to top layer
+        for i, layer in enumerate(old_image_config["history"]):
+            # If it's not an empty layer get the id
+            # (directory name) where the layer's data is
+            # stored
+            if not layer.get("empty_layer", False):
+                # Under <25 layers look like
+                # 27f9b97654306a5389e8e48ba3486a11026d34055e1907672231cbd8e1380481/layer.tar
+                # while >=25 layers look like
+                # blobs/sha256/d6a7fc1fb44b63324d3fc67f016e1ef7ecc1a5ae6668ae3072d2e17230e3cfbc
+                if self.oci_format:
+                    layer_id = old_image_manifest["Layers"][current_manifest_layer]
+                else:
+                    layer_id = old_image_manifest["Layers"][
+                        current_manifest_layer
+                    ].rsplit("/")[0]
+
+                # Check if this layer should be moved or squashed
+                if len(layers_to_move) > i:
+                    layer_paths_to_move.append(layer_id)
+                else:
+                    layer_paths_to_squash.append(layer_id)
+
+                current_manifest_layer += 1
+
+        return layer_paths_to_squash, layer_paths_to_move
+
+    def _generate_chain_id(self, chain_ids, diff_ids, parent_chain_id):
+        if parent_chain_id is None:
+            return self._generate_chain_id(chain_ids, diff_ids[1:], diff_ids[0])
+
+        chain_ids.append(parent_chain_id)
+
+        if len(diff_ids) == 0:
+            return parent_chain_id
+
+        # This probably should not be hardcoded
+        to_hash = "sha256:%s sha256:%s" % (parent_chain_id, diff_ids[0])
+        digest = hashlib.sha256(str(to_hash).encode("utf8")).hexdigest()
+
+        return self._generate_chain_id(chain_ids, diff_ids[1:], digest)
+
+    def _generate_chain_ids(self, diff_ids):
+        chain_ids: List[str] = []
+
+        self._generate_chain_id(chain_ids, diff_ids, None)
+
+        return chain_ids
+
+    def _generate_diff_ids(self):
+        diff_ids = []
+
+        for path in self.layer_paths_to_move:
+            sha256 = self._compute_sha256(self._extract_tar_name(path))
+            diff_ids.append(sha256)
+
+        if self.layer_paths_to_squash:
+            sha256 = self._compute_sha256(os.path.join(self.squashed_dir, "layer.tar"))
+            diff_ids.append(sha256)
+
+        return diff_ids
+
+    def _compress_squashed_layer(self):
+        """
+        Replace the squashed layer.tar with its gzip.
+
+        The containerd image store keeps a loaded layer as given and pushes it
+        as is, so a raw tar is pushed uncompressed. The daemon derives the
+        compressed digest itself and the config's diff ID still refers to the
+        uncompressed tar, so no other metadata changes. The mtime is fixed to
+        keep the output reproducible.
+        """
+        compressed = self.squashed_tar + ".gz"
+
+        with open(self.squashed_tar, "rb") as src, open(compressed, "wb") as raw:
+            with gzip.GzipFile(
+                filename="", mode="wb", fileobj=raw, compresslevel=9, mtime=0
+            ) as dst:
+                shutil.copyfileobj(src, dst)
+
+        os.replace(compressed, self.squashed_tar)
+
+    def _compute_sha256(self, layer_tar):
+        sha256 = hashlib.sha256()
+
+        with open(layer_tar, "rb") as f:
+            while True:
+                # Read in 10MB chunks
+                data = f.read(10485760)
+
+                if not data:
+                    break
+
+                sha256.update(data)
+
+        return sha256.hexdigest()
+
+    def _generate_squashed_layer_path_id(self):
+        """
+        This function generates the id used to name the directory to
+        store the squashed layer content in the archive.
+
+        This mimics what Docker does here: https://github.com/docker/docker/blob/v1.10.0-rc1/image/v1/imagev1.go#L42
+        To make it simpler we do reuse old image metadata and
+        modify it to what it should look which means to be exact
+        as https://github.com/docker/docker/blob/v1.10.0-rc1/image/v1/imagev1.go#L64
+        """
+
+        # Using OrderedDict, because order of JSON elements is important
+        v1_metadata = OrderedDict(self.old_image_config)
+
+        # Update image creation date
+        v1_metadata["created"] = self.date
+
+        # Remove unnecessary elements
+        # Do not fail if key is not found
+        for key in "history", "rootfs", "container":
+            v1_metadata.pop(key, None)
+
+        # Docker internally changes the order of keys between
+        # exported metadata (why oh why?!). We need to add 'os'
+        # element after 'layer_id'
+        operating_system = v1_metadata.pop("os", None)
+
+        # The 'layer_id' element is the chain_id of the
+        # squashed layer
+        v1_metadata["layer_id"] = "sha256:%s" % self.chain_ids[-1]
+
+        # Add back 'os' element
+        if operating_system:
+            v1_metadata["os"] = operating_system
+
+        # The 'parent' element is the name of the directory (inside the
+        # exported tar archive) of the last layer that we move
+        # (layer below squashed layer)
+
+        if self.layer_paths_to_move:
+            if self.layer_paths_to_squash:
+                parent = self.layer_paths_to_move[-1]
+            else:
+                parent = self.layer_paths_to_move[0]
+
+            v1_metadata["parent"] = "sha256:%s" % parent
+
+        # The 'Image' element is the id of the layer from which we squash
+        if self.squash_id:
+            # Update image id, should be one layer below squashed layer
+            v1_metadata["config"]["Image"] = self.squash_id
+        else:
+            v1_metadata["config"]["Image"] = ""
+
+        # Get the sha256sum of the JSON exported metadata,
+        # we do not care about the metadata anymore
+        sha = self._dump_json(v1_metadata)[1]
+
+        return sha
+
+    def _generate_last_layer_metadata(self, layer_path_id, old_layer_path: str):
+        config_file = os.path.join(self.old_image_dir, old_layer_path)
+        with open(config_file, "r") as f:
+            config = json.load(f, object_pairs_hook=OrderedDict)
+
+        config["created"] = self.date
+
+        if self.squash_id:
+            # Update image id, should be one layer below squashed layer
+            config["config"]["Image"] = self.squash_id
+        else:
+            config["config"]["Image"] = ""
+
+        # Update 'parent' - it should be path to the last layer to move
+        if self.layer_paths_to_move:
+            config["parent"] = self.layer_paths_to_move[-1]
+        else:
+            config.pop("parent", None)
+        # Update 'id' - it should be the path to the layer
+        config["id"] = layer_path_id
+        config.pop("container", None)
+        return config
+
+    def _generate_image_metadata(self):
+        # First - read old image config, we'll update it instead of
+        # generating one from scratch
+        metadata = OrderedDict(self.old_image_config)
+        # Update image creation date
+        metadata["created"] = self.date
+
+        # Remove unnecessary or old fields
+        metadata.pop("container", None)
+
+        # Remove squashed layers from history
+        metadata["history"] = metadata["history"][: len(self.layers_to_move)]
+        # Remove diff_ids for squashed layers
+        metadata["rootfs"]["diff_ids"] = metadata["rootfs"]["diff_ids"][
+            : len(self.layer_paths_to_move)
+        ]
+
+        history: Dict[str, Any] = {"comment": self.comment, "created": self.date}
+
+        if self.layer_paths_to_squash:
+            # Add diff_ids for the squashed layer
+            metadata["rootfs"]["diff_ids"].append("sha256:%s" % self.diff_ids[-1])
+        else:
+            history["empty_layer"] = True
+
+        # Add new entry for squashed layer to history
+        metadata["history"].append(history)
+
+        if self.squash_id:
+            # Update image id, should be one layer below squashed layer
+            metadata["config"]["Image"] = self.squash_id
+        else:
+            metadata["config"]["Image"] = ""
+
+        return metadata
+
+    def _get_manifest(self):
+        if os.path.exists(os.path.join(self.old_image_dir, "index.json")):
+            # New OCI Archive format type
+            self.oci_format = True
+            # Not using index.json to extract manifest details as while the config
+            # sha could be extracted via some indirection i.e.
+            #
+            # index.json:manifest/digest::sha256:<intermediary>
+            # blobs/sha256/<intermediary>:config/digest::sha256:<config>
+            #
+            # Docker spec currently will always include a manifest.json so will standardise
+            # on using that. Further we rely upon the original manifest format in order to write
+            # it back.
+            if os.path.exists(os.path.join(self.old_image_dir, "manifest.json")):
+                return (
+                    self._read_json_file(
+                        os.path.join(self.old_image_dir, "manifest.json")
+                    )
+                )[0]
+            else:
+                raise SquashError("Unable to locate manifest.json")
+        else:
+            return (
+                self._read_json_file(os.path.join(self.old_image_dir, "manifest.json"))
+            )[0]

docker_squash/version.py

@@ -0,0 +1 @@
+__version__ = "1.3.0"

docker_squash-1.3.0.dist-info/METADATA

@@ -0,0 +1,242 @@
+Metadata-Version: 2.4
+Name: docker-squash
+Version: 1.3.0
+Summary: Docker layer squashing tool
+Home-page: https://github.com/goldmann/docker-squash
+Download-URL: https://github.com/goldmann/docker-squash/archive/1.3.0.tar.gz
+Author: Marek Goldmann
+Author-email: marek.goldmann@gmail.com
+License: MIT
+Keywords: docker
+License-File: LICENSE
+Requires-Dist: docker
+Requires-Dist: packaging
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+``docker-squash``
+==================
+
+.. image:: https://github.com/goldmann/docker-squash/actions/workflows/squash.yml/badge.svg
+    :target: https://github.com/goldmann/docker-squash/actions/workflows/squash.yml
+
+The problem
+-----------
+
+Docker creates many layers while building the image. Sometimes it's not necessary or desireable
+to have them in the image. For example a Dockerfile `ADD` instruction creates a single layer
+with files you want to make available in the image. The problem arises when these files are
+only temporary files (for example product distribution that you want to unpack). Docker will
+carry this unnecessary layer always with the image, even if you delete these files in next
+layer. This a waste of time (more data to push/load/save) and resources (bigger image).
+
+Squashing helps with organizing images in logical layers. Instead of
+having an image with multiple (in almost all cases) unnecessary layers -
+we can control the structure of the image.
+
+Features
+--------
+
+- Can squash last n layers from an image
+- Can squash from a selected layer to the end (not always possible, depends on the image)
+- Support for Docker 1.9 or newer (older releases may run perfectly fine too, try it!)
+- Squashed image can be loaded back to the Docker daemon or stored as tar archive somewhere
+
+Installation
+------------
+
+From source code
+
+::
+
+    $ pip install --user https://github.com/goldmann/docker-squash/archive/master.zip
+
+From PyPi
+
+::
+
+    $ pip install docker-squash
+
+It is supported on Python 3.7 and above.
+
+Usage
+-----
+
+::
+
+    $ docker-squash -h
+    usage: cli.py [-h] [-v] [--version] [-d] [-f FROM_LAYER] [-t TAG]
+                  [--tmp-dir TMP_DIR] [--output-path OUTPUT_PATH]
+                  image
+
+    Docker layer squashing tool
+
+    positional arguments:
+      image                 Image to be squashed
+
+    optional arguments:
+      -h, --help            show this help message and exit
+      -v, --verbose         Verbose output
+      --version             Show version and exit
+      -f FROM_LAYER, --from-layer FROM_LAYER
+                            Number of layers to squash or ID of the layer (or image ID or image name) to squash from.
+                            In case the provided value is an integer, specified number of layers will be squashed.
+                            Every layer in the image will be squashed if the parameter is not provided.
+      -t TAG, --tag TAG     Specify the tag to be used for the new image. If not specified no tag will be applied
+      -m MESSAGE, --message MESSAGE
+                            Specify a commit message (comment) for the new image.
+      -c, --cleanup         Remove source image from Docker after squashing
+      --tmp-dir TMP_DIR     Temporary directory to be created and used. This will NOT be deleted afterwards for
+                            easier debugging.
+      --output-path OUTPUT_PATH
+                            Path where the image may be stored after squashing.
+      --load-image [LOAD_IMAGE]
+                            Whether to load the image into Docker daemon after squashing
+                            Default: true
+
+Note that environment variables may be set as documented in `here <docs/environment_variables.adoc>`_.
+
+License
+-------
+
+MIT
+
+Examples
+--------
+
+We start with image like this:
+
+::
+
+    $ docker history jboss/wildfly:latest
+    IMAGE               CREATED             CREATED BY                                      SIZE                COMMENT
+    25954e6d2300        3 weeks ago         /bin/sh -c #(nop) CMD ["/opt/jboss/wildfly/bi   0 B
+    5ae69cb454a5        3 weeks ago         /bin/sh -c #(nop) EXPOSE 8080/tcp               0 B
+    dc24712f35c4        3 weeks ago         /bin/sh -c #(nop) ENV LAUNCH_JBOSS_IN_BACKGRO   0 B
+    d929129d4c8e        3 weeks ago         /bin/sh -c cd $HOME     && curl -O https://do   160.8 MB
+    b8fa3caf7d6d        3 weeks ago         /bin/sh -c #(nop) ENV JBOSS_HOME=/opt/jboss/w   0 B
+    38b8f85e74bf        3 weeks ago         /bin/sh -c #(nop) ENV WILDFLY_SHA1=c0dd7552c5   0 B
+    ae79b646b9a9        3 weeks ago         /bin/sh -c #(nop) ENV WILDFLY_VERSION=10.0.0.   0 B
+    2b4606dc9dc7        3 weeks ago         /bin/sh -c #(nop) ENV JAVA_HOME=/usr/lib/jvm/   0 B
+    118fa9e33576        3 weeks ago         /bin/sh -c #(nop) USER [jboss]                  0 B
+    5f7e8f36c3bb        3 weeks ago         /bin/sh -c yum -y install java-1.8.0-openjdk-   197.4 MB
+    3d4d0228f161        3 weeks ago         /bin/sh -c #(nop) USER [root]                   0 B
+    f7ab4ea19708        3 weeks ago         /bin/sh -c #(nop) MAINTAINER Marek Goldmann <   0 B
+    4bb15f3b6977        3 weeks ago         /bin/sh -c #(nop) USER [jboss]                  0 B
+    5dc1e49f4361        3 weeks ago         /bin/sh -c #(nop) WORKDIR /opt/jboss            0 B
+    7f0f9eb31174        3 weeks ago         /bin/sh -c groupadd -r jboss -g 1000 && usera   4.349 kB
+    bd515f044af7        3 weeks ago         /bin/sh -c yum update -y && yum -y install xm   25.18 MB
+    b78336099045        3 weeks ago         /bin/sh -c #(nop) MAINTAINER Marek Goldmann <   0 B
+    4816a298548c        3 weeks ago         /bin/sh -c #(nop) CMD ["/bin/bash"]             0 B
+    6ee235cf4473        3 weeks ago         /bin/sh -c #(nop) LABEL name=CentOS Base Imag   0 B
+    474c2ee77fa3        3 weeks ago         /bin/sh -c #(nop) ADD file:72852fc7626d233343   196.6 MB
+    1544084fad81        6 months ago        /bin/sh -c #(nop) MAINTAINER The CentOS Proje   0 B
+
+And we want to squash all the layers down to layer ``4bb15f3b6977``.
+
+::
+
+    $ docker-squash -f 4bb15f3b6977 -t jboss/wildfly:squashed jboss/wildfly:latest
+    2016-04-01 13:11:02,358 root         INFO     docker-scripts version 1.0.0dev, Docker 7206621, API 1.21...
+    2016-04-01 13:11:02,358 root         INFO     Using v1 image format
+    2016-04-01 13:11:02,374 root         INFO     Old image has 21 layers
+    2016-04-01 13:11:02,378 root         INFO     Checking if squashing is necessary...
+    2016-04-01 13:11:02,378 root         INFO     Attempting to squash last 12 layers...
+    2016-04-01 13:11:02,378 root         INFO     Saving image 25954e6d230006235eecb7f0cc560264d73146985c2d2e663bac953d660b8730 to /tmp/docker-squash-fbxZz4/old/image.tar file...
+    2016-04-01 13:11:08,003 root         INFO     Image saved!
+    2016-04-01 13:11:08,031 root         INFO     Unpacking /tmp/docker-squash-fbxZz4/old/image.tar tar file to /tmp/docker-squash-fbxZz4/old directory
+    2016-04-01 13:11:08,588 root         INFO     Archive unpacked!
+    2016-04-01 13:11:08,636 root         INFO     Squashing image 'jboss/wildfly:latest'...
+    2016-04-01 13:11:08,637 root         INFO     Starting squashing...
+    2016-04-01 13:11:08,637 root         INFO     Squashing file '/tmp/docker-squash-fbxZz4/old/25954e6d230006235eecb7f0cc560264d73146985c2d2e663bac953d660b8730/layer.tar'...
+    2016-04-01 13:11:08,637 root         INFO     Squashing file '/tmp/docker-squash-fbxZz4/old/5ae69cb454a5a542f63e148ce40fb9e01de5bb01805b4ded238841bc2ce8e895/layer.tar'...
+    2016-04-01 13:11:08,637 root         INFO     Squashing file '/tmp/docker-squash-fbxZz4/old/dc24712f35c40e958be8aca2731e7bf8353b9b18baa6a94ad84c6952cbc77004/layer.tar'...
+    2016-04-01 13:11:08,638 root         INFO     Squashing file '/tmp/docker-squash-fbxZz4/old/d929129d4c8e61ea3661eb42c30d01f4c152418689178afc7dc8185a37814528/layer.tar'...
+    2016-04-01 13:11:09,113 root         INFO     Squashing file '/tmp/docker-squash-fbxZz4/old/b8fa3caf7d6dc228bf2499a3af86e5073ad0c17304c3900fa341e9d2fe4e5655/layer.tar'...
+    2016-04-01 13:11:09,115 root         INFO     Squashing file '/tmp/docker-squash-fbxZz4/old/38b8f85e74bfa773a0ad69da2205dc0148945e6f5a7ceb04fa4e8619e1de425b/layer.tar'...
+    2016-04-01 13:11:09,115 root         INFO     Squashing file '/tmp/docker-squash-fbxZz4/old/ae79b646b9a9a287c5f6a01871cc9d9ee596dafee2db942714ca3dea0c06eef3/layer.tar'...
+    2016-04-01 13:11:09,115 root         INFO     Squashing file '/tmp/docker-squash-fbxZz4/old/2b4606dc9dc773aa220a65351fe8d54f03534c58fea230960e95915222366074/layer.tar'...
+    2016-04-01 13:11:09,115 root         INFO     Squashing file '/tmp/docker-squash-fbxZz4/old/118fa9e33576ecc625ebbbfdf2809c1527e716cb4fd5cb40548eb6d3503a75a9/layer.tar'...
+    2016-04-01 13:11:09,115 root         INFO     Squashing file '/tmp/docker-squash-fbxZz4/old/5f7e8f36c3bb20c9db7470a22f828710b4d28aede64966c425add48a1b14fe23/layer.tar'...
+    2016-04-01 13:11:10,127 root         INFO     Squashing file '/tmp/docker-squash-fbxZz4/old/3d4d0228f161b67eb46fdb425ad148c31d9944dcb822f67eac3e2ac2effefc73/layer.tar'...
+    2016-04-01 13:11:10,129 root         INFO     Squashing file '/tmp/docker-squash-fbxZz4/old/f7ab4ea197084ab7483a2ca5409bdcf5473141bfb61b8687b1329943359cc3fe/layer.tar'...
+    2016-04-01 13:11:10,732 root         INFO     Squashing finished!
+    2016-04-01 13:11:10,737 root         INFO     New squashed image ID is 52255e75d3eb83123e074f897e8c971dec9d1168a5c82d7c1496a190da2e40ef
+    2016-04-01 13:11:14,563 root         INFO     Image registered in Docker daemon as jboss/wildfly:squashed
+    2016-04-01 13:11:14,652 root         INFO     Done
+
+We can now confirm the layer structure:
+
+::
+
+    $ docker history jboss/wildfly:squashed
+    IMAGE               CREATED             CREATED BY                                      SIZE                COMMENT
+    52255e75d3eb        40 seconds ago                                                      358.2 MB
+    4bb15f3b6977        3 weeks ago         /bin/sh -c #(nop) USER [jboss]                  0 B
+    5dc1e49f4361        3 weeks ago         /bin/sh -c #(nop) WORKDIR /opt/jboss            0 B
+    7f0f9eb31174        3 weeks ago         /bin/sh -c groupadd -r jboss -g 1000 && usera   4.349 kB
+    bd515f044af7        3 weeks ago         /bin/sh -c yum update -y && yum -y install xm   25.18 MB
+    b78336099045        3 weeks ago         /bin/sh -c #(nop) MAINTAINER Marek Goldmann <   0 B
+    4816a298548c        3 weeks ago         /bin/sh -c #(nop) CMD ["/bin/bash"]             0 B
+    6ee235cf4473        3 weeks ago         /bin/sh -c #(nop) LABEL name=CentOS Base Imag   0 B
+    474c2ee77fa3        3 weeks ago         /bin/sh -c #(nop) ADD file:72852fc7626d233343   196.6 MB
+    1544084fad81        6 months ago        /bin/sh -c #(nop) MAINTAINER The CentOS Proje   0 B
+
+Other option is to specify how many layers (counting from the newest layer) we want to squash.\
+Let's squash last 10 layers from the ``jboss/wildfly:latest`` image:
+
+::
+
+    $ docker-squash -f 10 -t jboss/wildfly:squashed jboss/wildfly:latest
+    2016-04-01 13:15:06,488 root         INFO     docker-scripts version 1.0.0dev, Docker 7206621, API 1.21...
+    2016-04-01 13:15:06,488 root         INFO     Using v1 image format
+    2016-04-01 13:15:06,504 root         INFO     Old image has 21 layers
+    2016-04-01 13:15:06,504 root         INFO     Checking if squashing is necessary...
+    2016-04-01 13:15:06,504 root         INFO     Attempting to squash last 10 layers...
+    2016-04-01 13:15:06,505 root         INFO     Saving image 25954e6d230006235eecb7f0cc560264d73146985c2d2e663bac953d660b8730 to /tmp/docker-squash-fu80CX/old/image.tar file...
+    2016-04-01 13:15:12,136 root         INFO     Image saved!
+    2016-04-01 13:15:12,167 root         INFO     Unpacking /tmp/docker-squash-fu80CX/old/image.tar tar file to /tmp/docker-squash-fu80CX/old directory
+    2016-04-01 13:15:12,706 root         INFO     Archive unpacked!
+    2016-04-01 13:15:12,756 root         INFO     Squashing image 'jboss/wildfly:latest'...
+    2016-04-01 13:15:12,756 root         INFO     Starting squashing...
+    2016-04-01 13:15:12,756 root         INFO     Squashing file '/tmp/docker-squash-fu80CX/old/25954e6d230006235eecb7f0cc560264d73146985c2d2e663bac953d660b8730/layer.tar'...
+    2016-04-01 13:15:12,757 root         INFO     Squashing file '/tmp/docker-squash-fu80CX/old/5ae69cb454a5a542f63e148ce40fb9e01de5bb01805b4ded238841bc2ce8e895/layer.tar'...
+    2016-04-01 13:15:12,757 root         INFO     Squashing file '/tmp/docker-squash-fu80CX/old/dc24712f35c40e958be8aca2731e7bf8353b9b18baa6a94ad84c6952cbc77004/layer.tar'...
+    2016-04-01 13:15:12,757 root         INFO     Squashing file '/tmp/docker-squash-fu80CX/old/d929129d4c8e61ea3661eb42c30d01f4c152418689178afc7dc8185a37814528/layer.tar'...
+    2016-04-01 13:15:13,234 root         INFO     Squashing file '/tmp/docker-squash-fu80CX/old/b8fa3caf7d6dc228bf2499a3af86e5073ad0c17304c3900fa341e9d2fe4e5655/layer.tar'...
+    2016-04-01 13:15:13,235 root         INFO     Squashing file '/tmp/docker-squash-fu80CX/old/38b8f85e74bfa773a0ad69da2205dc0148945e6f5a7ceb04fa4e8619e1de425b/layer.tar'...
+    2016-04-01 13:15:13,235 root         INFO     Squashing file '/tmp/docker-squash-fu80CX/old/ae79b646b9a9a287c5f6a01871cc9d9ee596dafee2db942714ca3dea0c06eef3/layer.tar'...
+    2016-04-01 13:15:13,235 root         INFO     Squashing file '/tmp/docker-squash-fu80CX/old/2b4606dc9dc773aa220a65351fe8d54f03534c58fea230960e95915222366074/layer.tar'...
+    2016-04-01 13:15:13,236 root         INFO     Squashing file '/tmp/docker-squash-fu80CX/old/118fa9e33576ecc625ebbbfdf2809c1527e716cb4fd5cb40548eb6d3503a75a9/layer.tar'...
+    2016-04-01 13:15:13,236 root         INFO     Squashing file '/tmp/docker-squash-fu80CX/old/5f7e8f36c3bb20c9db7470a22f828710b4d28aede64966c425add48a1b14fe23/layer.tar'...
+    2016-04-01 13:15:14,848 root         INFO     Squashing finished!
+    2016-04-01 13:15:14,853 root         INFO     New squashed image ID is fde7edd2e5683c97bedf9c0bf52ad5150db5650e421de3d9293ce5223b256455
+    2016-04-01 13:15:18,963 root         INFO     Image registered in Docker daemon as jboss/wildfly:squashed
+    2016-04-01 13:15:19,059 root         INFO     Done
+
+Let's confirm the image structure now:
+
+::
+
+    $ docker history jboss/wildfly:squashed
+    IMAGE               CREATED             CREATED BY                                      SIZE                COMMENT
+    fde7edd2e568        32 seconds ago                                                      358.2 MB
+    3d4d0228f161        3 weeks ago         /bin/sh -c #(nop) USER [root]                   0 B
+    f7ab4ea19708        3 weeks ago         /bin/sh -c #(nop) MAINTAINER Marek Goldmann <   0 B
+    4bb15f3b6977        3 weeks ago         /bin/sh -c #(nop) USER [jboss]                  0 B
+    5dc1e49f4361        3 weeks ago         /bin/sh -c #(nop) WORKDIR /opt/jboss            0 B
+    7f0f9eb31174        3 weeks ago         /bin/sh -c groupadd -r jboss -g 1000 && usera   4.349 kB
+    bd515f044af7        3 weeks ago         /bin/sh -c yum update -y && yum -y install xm   25.18 MB
+    b78336099045        3 weeks ago         /bin/sh -c #(nop) MAINTAINER Marek Goldmann <   0 B
+    4816a298548c        3 weeks ago         /bin/sh -c #(nop) CMD ["/bin/bash"]             0 B
+    6ee235cf4473        3 weeks ago         /bin/sh -c #(nop) LABEL name=CentOS Base Imag   0 B
+    474c2ee77fa3        3 weeks ago         /bin/sh -c #(nop) ADD file:72852fc7626d233343   196.6 MB
+    1544084fad81        6 months ago        /bin/sh -c #(nop) MAINTAINER The CentOS Proje   0 B