Welcome to the next step in your journey of mastering API interactions with Ruby! In our previous lesson, you learned how to download files efficiently using an API, enhancing your skills in file management. Today, we will take a look at the reverse process: uploading files to an API. This capability is crucial for creating applications that need to store or share files, such as documents, images, or any other type of data with an external server.

Understanding file uploads will further expand your ability to interact with APIs, equipping you to build more robust and feature-complete applications. By the end of this lesson, you will learn how to send a file to a server using Ruby, ensuring that you can manage uploads confidently and efficiently.

To upload files via HTTP, the POST method is commonly used, as it’s designed for submitting data to a server, including files. The key to sending files is using multipart/form-data, a format that allows both text and binary data to be sent together, organized into separate parts. This format ensures the server can properly handle the uploaded file along with any additional data.

In Ruby, the Net::HTTP library can be used to handle this process. While Ruby does not have a built-in method to automatically handle multipart/form-data, you can use additional libraries like multipart-post to simplify the process.

Here's a simple example showing how to upload a file using Net::HTTP and multipart-post:

require 'net/http'
require 'uri'
require 'net/http/post/multipart'

# Open the file in binary read mode
File.open("file.txt", "rb") do |file|
  # Create a URI object for the server endpoint
  uri = URI("http://example.com/upload")

  # Create a multipart POST request
  request = Net::HTTP::Post::Multipart.new uri.path,
                                           "file" => UploadIO.new(file, "text/plain", "file.txt")

  # Send the request to the server
  response = Net::HTTP.start(uri.host, uri.port) do |http|
    http.request(request)
  end

  puts response.body
end

In this example, the file is opened in binary mode ("rb") to ensure its data is read correctly.

• File.open("file.txt", "rb"): Opens the file in read-binary mode, preserving the exact byte structure. This is essential for reading non-text files like images or PDFs.
• File.open("file.txt", "wb"): Opens the file in write-binary mode, ensuring data is written as raw bytes. This overwrites any existing content and is crucial for saving binary files without encoding issues.
• File.open("file.txt", "w"): Opens the file in write mode, designed for text files. It overwrites existing content and may apply character encoding conversions based on system defaults.

The UploadIO class from multipart-post is used to specify which file to upload. The Net::HTTP library then sends the request, making file uploads straightforward and allowing you to focus on the functionality of your application.

Now, let's delve into the process of uploading a file using Ruby. Consider the following code example, which utilizes the "/notes" endpoint to upload a file named meeting_notes.txt.

require 'net/http'
require 'uri'
require 'net/http/post/multipart'

# Base URL for the API
base_url = "http://localhost:8000"

# Specify the file name to upload
file_name = "meeting_notes.txt"

begin
  # Open the file in binary read mode
  File.open(file_name, "rb") do |file|
    # Create a URI object for the server endpoint
    uri = URI("#{base_url}/notes")

    # Create a multipart POST request
    request = Net::HTTP::Post::Multipart.new uri.path,
                                             "file" => UploadIO.new(file, "text/plain", file_name)

    # Send the request to the server
    response = Net::HTTP.start(uri.host, uri.port) do |http|
      http.request(request)
    end

    # Check for HTTP errors
    if response.is_a?(Net::HTTPSuccess)
      puts "File uploaded successfully: #{file_name}"
    else
      puts "HTTP error occurred: #{response.message}"
    end
  end

rescue Errno::ENOENT
  # Handle the case where the file specified does not exist
  puts "File not found: #{file_name}"
rescue StandardError => e
  # Handle all other types of exceptions
  puts "An error occurred: #{e.message}"
end

This code example demonstrates how to properly upload a file to an API:

• The File.open function opens the file in binary mode (rb), which is essential for properly handling the file data.
• The Net::HTTP::Post::Multipart function sends a POST request to the API's /notes endpoint, attaching the file in the request.
• If the upload is successful, a success message is printed to the console.

In this example, requests are encapsulated in a begin-rescue block to gracefully address potential issues. An Errno::ENOENT is handled, which will be triggered if the file specified for upload cannot be located. By managing these exceptions, you can ensure your application behaves predictably, even if something goes wrong during file upload.

Once a file is uploaded, it's important to verify it to ensure that the file is stored correctly on the server. You can achieve this by sending a GET request to the corresponding endpoint and checking the content of the uploaded file.

# Verify the file upload by retrieving the file content from the server
begin
  uri = URI("#{base_url}/notes/#{file_name}")
  response = Net::HTTP.get_response(uri)

  if response.is_a?(Net::HTTPSuccess)
    # Print the content of the file
    puts response.body
  else
    puts "HTTP error occurred: #{response.message}"
  end

rescue StandardError => e
  puts "An error occurred: #{e.message}"
end

In this code, we retrieve the content of the file from the server and print it out. This allows us to confirm that the file has been uploaded and stored successfully.

Meeting Notes

Date: 2023-10-18
Time: 3:00 PM
Location: Conference Room A

Attendees:
- Alice Johnson
- Bob Smith
- Charlie Brown
...

This output confirms that the file meeting_notes.txt is present on the server and its contents are intact, with details such as the date, time, location, and attendees of a meeting.

In this lesson, you built upon your previous knowledge of file downloads and learned to upload files to a server using Ruby's Net::HTTP library along with multipart-post. We explored the steps to set up your environment, the importance of opening files in binary mode, and the method to send POST requests for file uploads. You also learned how robust error handling can lead to more reliable applications.

Now, it's time to get hands-on with the practical exercises following this lesson. Use these exercises as an opportunity to reinforce your understanding and experiment with different file types and sizes. This will not only enhance your skills but also prepare you for advanced API interactions in future lessons. Happy coding, and keep up the excellent work!