docker_mcp 0.0.1 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13aa3a020b35fdc5882599c7e62c9507a776ee61bcacf0e503b5112c7983cbab
-  data.tar.gz: b43e7dd8b18b6872c389211ec44a290e12b110d3e4b5bbe9292387bb581e8b69
+  metadata.gz: efb62c57572aa0d7838b21fb503cc82d4d29b1b7a4b67a56a73403abf95569cd
+  data.tar.gz: 659cee10a2d4bb77b2a4dabe5acf47c63415e17e67b34f3046eb5bbb149ca9a1
 SHA512:
-  metadata.gz: 34ded89e697e7f03614625faf3f0edf4489454385ee707cce29465a739976661f157504bb2a71f497c1abcb6f6fdd9776dab703518a0f5f94f0a30326452ae0b
-  data.tar.gz: cd6830efe07d41492b349cb15ac11a3ffdbf085de1639e502eef23db62773c4127fa8e8966225bbb4b5eabeb7e25e40fb94471d14490166b14530746eb057eda
+  metadata.gz: f24eb8a997aa33b2a4389170fd3d938d9ac0e00fec6f437074497ddfc260d81a8390b61b883caf35901d19f34af271b1d8d32f3b5ff24ca51dea9c885cb9e7c7
+  data.tar.gz: 68672e9b0c1432fa2575aea0034d4d4d74e872d83da97456d2fc0cc698249fd643d9325cfc9ed25223f3832b980926212fc98d228d135a10180c7cdd8ea8e0d5

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Aaron F Stanton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -1,35 +1,271 @@
-# DockerMcp
+# DockerMCP
 
-TODO: Delete this and the text below, and describe your gem
+A Model Context Protocol (MCP) server that provides comprehensive Docker management capabilities through a standardized interface. This tool enables AI assistants and other MCP clients to interact with Docker containers, images, networks, and volumes programmatically.
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/docker_mcp`. To experiment with that code, run `bin/console` for an interactive prompt.
+## ⚠️ Security Warning
 
-## Installation
+**This tool is inherently unsafe and should be used with extreme caution.**
+
+- **Arbitrary Code Execution**: The `exec_container` tool allows execution of arbitrary commands inside Docker containers
+- **File System Access**: The `copy_to_container` tool can copy files from the host system into containers
+- **Container Management**: Full container lifecycle management including creation, modification, and deletion
+- **Network & Volume Control**: Complete control over Docker networks and volumes
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+**Recommendations:**
+- Only use in trusted environments
+- Ensure proper Docker daemon security configuration
+- Consider running with restricted Docker permissions
+- Monitor and audit all container operations
+- Be cautious when exposing this tool to external or untrusted MCP clients
+
+## Installation
 
 Install the gem and add to the application's Gemfile by executing:
 
 ```bash
-bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+bundle add docker_mcp
 ```
 
 If bundler is not being used to manage dependencies, install the gem by executing:
 
 ```bash
-gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+gem install docker_mcp
 ```
 
+## Prerequisites
+
+- Docker Engine installed and running
+- Ruby 3.2+
+- Docker permissions for the user running the MCP server
+
 ## Usage
 
-TODO: Write usage instructions here
+### MCP Client Configuration
+
+Add this to your MCP client configuration after installing the gem:
+
+```json
+{
+  "docker_mcp": {
+    "command": "bash",
+    "args": [
+      "-l",
+      "-c",
+      "docker_mcp"
+    ]
+  }
+}
+```
+
+### Example Usage
+
+Once configured, you can use the tools through your MCP client:
+
+```
+# List all containers
+list_containers
+
+# Create and run a new container
+run_container image="nginx:latest" name="my-web-server"
+
+# Execute commands in a container
+exec_container id="my-web-server" cmd="nginx -v"
+
+# Copy files to a container
+copy_to_container id="my-web-server" source_path="/local/file.txt" destination_path="/var/www/html/"
+
+# View container logs
+fetch_container_logs id="my-web-server"
+```
+
+## 🔨 Tools
+
+This MCP server provides 22 comprehensive Docker management tools organized by functionality:
+
+### Container Management
+
+- **`list_containers`** - List all Docker containers (running and stopped) with detailed information
+- **`create_container`** - Create a new container from an image without starting it
+- **`run_container`** - Create and immediately start a container from an image
+- **`start_container`** - Start an existing stopped container
+- **`stop_container`** - Stop a running container gracefully
+- **`remove_container`** - Delete a container (must be stopped first unless forced)
+- **`recreate_container`** - Stop, remove, and recreate a container with the same configuration
+- **`exec_container`** ⚠️ - Execute arbitrary commands inside a running container
+- **`fetch_container_logs`** - Retrieve stdout/stderr logs from a container
+- **`copy_to_container`** ⚠️ - Copy files or directories from host to container
+
+### Image Management
+
+- **`list_images`** - List all Docker images available locally
+- **`pull_image`** - Download an image from a Docker registry
+- **`push_image`** - Upload an image to a Docker registry
+- **`build_image`** - Build a new image from a Dockerfile
+- **`tag_image`** - Create a new tag for an existing image
+- **`remove_image`** - Delete an image from local storage
+
+### Network Management
+
+- **`list_networks`** - List all Docker networks
+- **`create_network`** - Create a new Docker network
+- **`remove_network`** - Delete a Docker network
+
+### Volume Management
+
+- **`list_volumes`** - List all Docker volumes
+- **`create_volume`** - Create a new Docker volume for persistent data
+- **`remove_volume`** - Delete a Docker volume
+
+### Tool Parameters
+
+Most tools accept standard Docker parameters:
+- **Container ID/Name**: Can use either the full container ID, short ID, or container name
+- **Image**: Specify images using `name:tag` format (e.g., `nginx:latest`, `ubuntu:22.04`)
+- **Ports**: Use Docker port mapping syntax (e.g., `"8080:80"`)
+- **Volumes**: Use Docker volume mount syntax (e.g., `"/host/path:/container/path"`)
+- **Environment**: Set environment variables as `KEY=VALUE` pairs
+
+## Common Use Cases
+
+### Development Environment Setup
+```bash
+# Pull development image
+pull_image from_image="node:18-alpine"
+
+# Create development container with volume mounts
+run_container image="node:18-alpine" name="dev-env" \
+  host_config='{"PortBindings":{"3000/tcp":[{"HostPort":"3000"}]},"Binds":["/local/project:/app"]}'
+
+# Execute development commands
+exec_container id="dev-env" cmd="npm install"
+exec_container id="dev-env" cmd="npm start"
+```
+
+### Container Debugging
+```bash
+# Check container status
+list_containers
+
+# View container logs
+fetch_container_logs id="problematic-container"
+
+# Execute diagnostic commands
+exec_container id="problematic-container" cmd="ps aux"
+exec_container id="problematic-container" cmd="df -h"
+exec_container id="problematic-container" cmd="netstat -tlnp"
+```
+
+### File Management
+```bash
+# Copy configuration files to container
+copy_to_container id="web-server" \
+  source_path="/local/nginx.conf" \
+  destination_path="/etc/nginx/"
+
+# Copy application code
+copy_to_container id="app-container" \
+  source_path="/local/src" \
+  destination_path="/app/"
+```
+
+## Error Handling
+
+The server provides detailed error messages for common issues:
+
+- **Container Not Found**: When referencing non-existent containers
+- **Image Not Available**: When trying to use images that aren't pulled locally
+- **Permission Denied**: When Docker daemon access is restricted
+- **Network Conflicts**: When creating networks with conflicting configurations
+- **Volume Mount Issues**: When specified paths don't exist or lack permissions
+
+All errors include descriptive messages to help diagnose and resolve issues.
+
+## Troubleshooting
+
+### Docker Daemon Connection Issues
+```bash
+# Check if Docker daemon is running
+docker info
+
+# Verify Docker permissions
+docker ps
+
+# Check MCP server logs for connection errors
+```
+
+### Container Operation Failures
+- Ensure container IDs/names are correct (use `list_containers` to verify)
+- Check if containers are in the expected state (running/stopped)
+- Verify image availability with `list_images`
+
+### Permission Issues
+- Ensure the user running the MCP server has Docker permissions
+- Consider adding user to the `docker` group: `sudo usermod -aG docker $USER`
+- Verify Docker socket permissions: `ls -la /var/run/docker.sock`
+
+## Limitations
+
+- **Platform Specific**: Some container operations may behave differently across operating systems
+- **Docker API Version**: Requires compatible Docker Engine API version
+- **Resource Limits**: Large file copies and image operations may timeout
+- **Concurrent Operations**: Heavy concurrent usage may impact performance
+
+## Contributing
+
+We welcome contributions! Areas for improvement:
+
+- **Enhanced Security**: Additional safety checks and permission validation
+- **Better Error Handling**: More specific error messages and recovery suggestions
+- **Performance Optimization**: Streaming for large file operations
+- **Extended Functionality**: Support for Docker Compose, Swarm, etc.
+- **Testing**: Comprehensive test coverage for all tools
 
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
+### Running Tests
+```bash
+# Install dependencies
+bundle install
+
+# Run the test suite
+bundle exec rake spec
+
+# Run tests with coverage
+bundle exec rake spec COVERAGE=true
+```
+
+### Local Development Setup
+```bash
+# Clone the repository
+git clone https://github.com/afstanton/docker_mcp.git
+cd docker_mcp
+
+# Install dependencies
+bin/setup
+
+# Start development console
+bin/console
+
+# Build the gem locally
+bundle exec rake build
+
+# Install locally built gem
+bundle exec rake install
+```
+
+### Testing with MCP Client
+```bash
+# Start the MCP server locally
+bundle exec exe/docker_mcp
+
+# Configure your MCP client to use local development server
+# Use file path instead of installed gem command
+```
+
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
-## Contributing
+## License
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/docker_mcp.
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-require "rubocop/rake_task"
+require 'rubocop/rake_task'
 
 RuboCop::RakeTask.new
 

data/exe/docker_mcp

@@ -0,0 +1,8 @@
+require 'docker_mcp'
+
+# Set up the server
+server = DockerMCP::Server.new.server
+
+# Create and start the transport
+transport = MCP::Server::Transports::StdioTransport.new(server)
+transport.open

data/lib/docker_mcp/build_image.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module DockerMCP
+  # MCP tool for building Docker images from Dockerfile content.
+  #
+  # This tool provides the ability to build Docker images by providing Dockerfile
+  # content as a string. It supports optional tagging of the resulting image for
+  # easy identification and reuse.
+  #
+  # == Security Considerations
+  #
+  # Building Docker images can be potentially dangerous:
+  # - Dockerfile commands execute with Docker daemon privileges
+  # - Images can contain malicious software or backdoors
+  # - Build process can access host resources (network, files)
+  # - Base images may contain vulnerabilities
+  # - Build context may expose sensitive information
+  #
+  # Security recommendations:
+  # - Review Dockerfile content carefully before building
+  # - Use trusted base images from official repositories
+  # - Scan built images for vulnerabilities
+  # - Limit network access during builds
+  # - Avoid including secrets in Dockerfile instructions
+  # - Use multi-stage builds to minimize final image size
+  #
+  # == Features
+  #
+  # - Build images from Dockerfile content strings
+  # - Optional image tagging during build
+  # - Comprehensive error handling
+  # - Support for all standard Dockerfile instructions
+  # - Returns image ID and build status
+  #
+  # == Example Usage
+  #
+  #   # Simple image build
+  #   BuildImage.call(
+  #     server_context: context,
+  #     dockerfile: "FROM alpine:latest\nRUN apk add --no-cache curl"
+  #   )
+  #
+  #   # Build with custom tag
+  #   BuildImage.call(
+  #     server_context: context,
+  #     dockerfile: dockerfile_content,
+  #     tag: "myapp:v1.0"
+  #   )
+  #
+  # @see Docker::Image.build
+  # @see TagImage
+  # @since 0.1.0
+  class BuildImage < MCP::Tool
+    description 'Build a Docker image'
+
+    input_schema(
+      properties: {
+        dockerfile: {
+          type: 'string',
+          description: 'Dockerfile content as a string'
+        },
+        tag: {
+          type: 'string',
+          description: 'Tag for the built image (e.g., "myimage:latest")'
+        }
+      },
+      required: ['dockerfile']
+    )
+
+    # Build a Docker image from Dockerfile content.
+    #
+    # This method creates a Docker image by building from the provided Dockerfile
+    # content string. The Dockerfile is processed by the Docker daemon and can
+    # include any valid Dockerfile instructions. Optionally, the resulting image
+    # can be tagged with a custom name for easy reference.
+    #
+    # @param dockerfile [String] the complete Dockerfile content as a string
+    # @param server_context [Object] MCP server context (unused but required)
+    # @param tag [String, nil] optional tag to apply to the built image
+    #
+    # @return [MCP::Tool::Response] build results including image ID and tag info
+    #
+    # @raise [Docker::Error] for Docker daemon communication errors
+    # @raise [StandardError] for build failures or other errors
+    #
+    # @example Build simple image
+    #   dockerfile = <<~DOCKERFILE
+    #     FROM alpine:latest
+    #     RUN apk add --no-cache nginx
+    #     EXPOSE 80
+    #     CMD ["nginx", "-g", "daemon off;"]
+    #   DOCKERFILE
+    #
+    #   response = BuildImage.call(
+    #     server_context: context,
+    #     dockerfile: dockerfile,
+    #     tag: "my-nginx:latest"
+    #   )
+    #
+    # @see Docker::Image.build
+    def self.call(dockerfile:, server_context:, tag: nil)
+      # Build the image
+      image = Docker::Image.build(dockerfile)
+
+      # If a tag was specified, tag the image
+      if tag
+        # Split tag into repo and tag parts
+        repo, image_tag = tag.split(':', 2)
+        image_tag ||= 'latest'
+        image.tag('repo' => repo, 'tag' => image_tag, 'force' => true)
+      end
+
+      response_text = "Image built successfully. ID: #{image.id}"
+      response_text += ", Tag: #{tag}" if tag
+
+      MCP::Tool::Response.new([{
+                                type: 'text',
+                                text: response_text
+                              }])
+    rescue StandardError => e
+      MCP::Tool::Response.new([{
+                                type: 'text',
+                                text: "Error building image: #{e.message}"
+                              }])
+    end
+  end
+end

data/lib/docker_mcp/copy_to_container.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module DockerMCP
+  # MCP tool for copying files and directories from host to Docker containers.
+  #
+  # This tool provides the ability to copy files or entire directory trees from
+  # the host filesystem into running Docker containers. It uses Docker's archive
+  # streaming API to efficiently transfer files while preserving permissions and
+  # directory structure.
+  #
+  # == ⚠️ SECURITY WARNING ⚠️
+  #
+  # This tool can be dangerous as it allows:
+  # - Reading arbitrary files from the host filesystem
+  # - Writing files into container filesystems
+  # - Potentially overwriting critical container files
+  # - Escalating privileges if used with setuid/setgid files
+  # - Exposing sensitive host data to containers
+  #
+  # Security recommendations:
+  # - Validate source paths to prevent directory traversal
+  # - Ensure containers run with minimal privileges
+  # - Monitor file copy operations for sensitive paths
+  # - Use read-only filesystems where possible
+  # - Implement proper access controls on source files
+  #
+  # == Features
+  #
+  # - Copy individual files or entire directories
+  # - Preserve file permissions and directory structure
+  # - Optional ownership changes after copy
+  # - Comprehensive error handling
+  # - Support for both absolute and relative paths
+  #
+  # == Example Usage
+  #
+  #   # Copy a configuration file
+  #   CopyToContainer.call(
+  #     server_context: context,
+  #     id: "web-server",
+  #     source_path: "/host/config/nginx.conf",
+  #     destination_path: "/etc/nginx/"
+  #   )
+  #
+  #   # Copy directory with ownership change
+  #   CopyToContainer.call(
+  #     server_context: context,
+  #     id: "app-container",
+  #     source_path: "/host/app/src",
+  #     destination_path: "/app/",
+  #     owner: "appuser:appgroup"
+  #   )
+  #
+  # @see Docker::Container#archive_in_stream
+  # @since 0.1.0
+  class CopyToContainer < MCP::Tool
+    description 'Copy a file or directory from the local filesystem into a running Docker container. ' \
+                'The source path is on the local machine, and the destination path is inside the container.'
+
+    input_schema(
+      properties: {
+        id: {
+          type: 'string',
+          description: 'Container ID or name'
+        },
+        source_path: {
+          type: 'string',
+          description: 'Path to the file or directory on the local filesystem to copy'
+        },
+        destination_path: {
+          type: 'string',
+          description: 'Path inside the container where the file/directory should be copied'
+        },
+        owner: {
+          type: 'string',
+          description: 'Owner for the copied files (optional, e.g., "1000:1000" or "username:group")'
+        }
+      },
+      required: %w[id source_path destination_path]
+    )
+
+    # Copy files or directories from host filesystem to a Docker container.
+    #
+    # This method creates a tar archive of the source path and streams it into
+    # the specified container using Docker's archive API. The operation preserves
+    # file permissions and directory structure. Optionally, ownership can be
+    # changed after the copy operation completes.
+    #
+    # The source path must exist on the host filesystem and be readable by the
+    # process running the MCP server. The destination path must be a valid path
+    # within the container.
+    #
+    # @param id [String] container ID or name to copy files into
+    # @param source_path [String] path to file/directory on host filesystem
+    # @param destination_path [String] destination path inside container
+    # @param server_context [Object] MCP server context (unused but required)
+    # @param owner [String, nil] ownership specification (e.g., "user:group", "1000:1000")
+    #
+    # @return [MCP::Tool::Response] success/failure message with operation details
+    #
+    # @raise [Docker::Error::NotFoundError] if container doesn't exist
+    # @raise [StandardError] for file system or Docker API errors
+    #
+    # @example Copy configuration file
+    #   response = CopyToContainer.call(
+    #     server_context: context,
+    #     id: "nginx-container",
+    #     source_path: "/etc/nginx/sites-available/default",
+    #     destination_path: "/etc/nginx/sites-enabled/"
+    #   )
+    #
+    # @example Copy directory with ownership
+    #   response = CopyToContainer.call(
+    #     server_context: context,
+    #     id: "app-container",
+    #     source_path: "/local/project",
+    #     destination_path: "/app/",
+    #     owner: "www-data:www-data"
+    #   )
+    #
+    # @see Docker::Container#archive_in_stream
+    # @see #add_to_tar
+    def self.call(id:, source_path:, destination_path:, server_context:, owner: nil)
+      container = Docker::Container.get(id)
+
+      # Verify source path exists
+      unless File.exist?(source_path)
+        return MCP::Tool::Response.new([{
+                                         type: 'text',
+                                         text: "Source path not found: #{source_path}"
+                                       }])
+      end
+
+      # Create a tar archive of the source
+      tar_io = StringIO.new
+      tar_io.set_encoding('ASCII-8BIT')
+
+      Gem::Package::TarWriter.new(tar_io) do |tar|
+        add_to_tar(tar, source_path, File.basename(source_path))
+      end
+
+      tar_io.rewind
+
+      # Copy to container
+      container.archive_in_stream(destination_path) do
+        tar_io.read
+      end
+
+      # Optionally change ownership
+      if owner
+        chown_path = File.join(destination_path, File.basename(source_path))
+        container.exec(['chown', '-R', owner, chown_path])
+      end
+
+      file_type = File.directory?(source_path) ? 'directory' : 'file'
+      response_text = "Successfully copied #{file_type} from #{source_path} to #{id}:#{destination_path}"
+      response_text += "\nOwnership changed to #{owner}" if owner
+
+      MCP::Tool::Response.new([{
+                                type: 'text',
+                                text: response_text
+                              }])
+    rescue Docker::Error::NotFoundError
+      MCP::Tool::Response.new([{
+                                type: 'text',
+                                text: "Container #{id} not found"
+                              }])
+    rescue StandardError => e
+      MCP::Tool::Response.new([{
+                                type: 'text',
+                                text: "Error copying to container: #{e.message}"
+                              }])
+    end
+
+    # Recursively add files and directories to a tar archive.
+    #
+    # This helper method builds a tar archive by recursively traversing
+    # the filesystem starting from the given path. It preserves file
+    # permissions and handles both files and directories appropriately.
+    #
+    # For directories, it creates directory entries in the tar and then
+    # recursively processes all contained files and subdirectories.
+    # For files, it reads the content and adds it to the tar with
+    # preserved permissions.
+    #
+    # @param tar [Gem::Package::TarWriter] the tar writer instance
+    # @param path [String] the filesystem path to add to the archive
+    # @param archive_path [String] the path within the tar archive
+    #
+    # @return [void]
+    #
+    # @example Add single file
+    #   add_to_tar(tar_writer, "/host/file.txt", "file.txt")
+    #
+    # @example Add directory tree
+    #   add_to_tar(tar_writer, "/host/mydir", "mydir")
+    #
+    # @see Gem::Package::TarWriter#mkdir
+    # @see Gem::Package::TarWriter#add_file_simple
+    def self.add_to_tar(tar, path, archive_path)
+      if File.directory?(path)
+        # Add directory entry
+        tar.mkdir(archive_path, File.stat(path).mode)
+
+        # Add directory contents
+        Dir.entries(path).each do |entry|
+          next if ['.', '..'].include?(entry)
+
+          full_path = File.join(path, entry)
+          archive_entry_path = File.join(archive_path, entry)
+          add_to_tar(tar, full_path, archive_entry_path)
+        end
+      else
+        # Add file
+        File.open(path, 'rb') do |file|
+          tar.add_file_simple(archive_path, File.stat(path).mode, file.size) do |tar_file|
+            IO.copy_stream(file, tar_file)
+          end
+        end
+      end
+    end
+  end
+end