Building a CLI for File System Operations in Go

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setup
  4. Creating the CLI
  5. File System Operations
  6. Conclusion

Introduction

In this tutorial, we will learn how to build a Command Line Interface (CLI) tool using Go (or Golang). The CLI tool will allow users to perform various file system operations efficiently and effectively. By the end of this tutorial, you will have a solid understanding of how to create a CLI tool in Go and how to interact with the file system using Go’s built-in packages.

Prerequisites

Before you begin this tutorial, make sure you have the following prerequisites:

  1. Basic knowledge of Go programming language.

  2. Go installed on your machine with the $GOPATH environment variable set.

Setup

To set up your environment for building the CLI, follow these steps:

  1. Open your command line interface.

  2. Create a new directory for your project and navigate into it.

  3. Initialize a new Go module by running the command: 
     go mod init <module-name>

Creating the CLI

Now let’s start building our CLI tool. We will use the flag package from the standard library to parse command-line arguments. Create a new file called main.go and open it in your favorite text editor.

Add the following code to import the necessary packages:

package main

import (
	"flag"
	"fmt"
	"os"
)

Next, let’s define the main function and parse the command-line arguments using the flag package:

func main() {
	// Define command-line flags
	operation := flag.String("operation", "", "Specify the file system operation to perform.")
	filePath := flag.String("file", "", "Specify the file path for the operation.")
	flag.Parse()

	// Check if mandatory flags are provided
	if *operation == "" {
		fmt.Println("Please specify the file system operation using the -operation flag.")
		os.Exit(1)
	}

	// Perform the specified operation
	switch *operation {
	case "create":
		// Call a function to create a new file
	case "read":
		// Call a function to read file contents
	case "update":
		// Call a function to update a file
	case "delete":
		// Call a function to delete a file
	default:
		fmt.Println("Invalid operation. Please specify a valid file system operation.")
		os.Exit(1)
	}
}

At this point, we have defined the structure of our CLI tool and added code to parse the command-line arguments. We will now implement the file system operations in the next section.

File System Operations

In this section, we will implement the file system operations mentioned in the switch statement above. Let’s start with the “create” operation.

Create Operation

To create a new file, we will use the os package provided by Go’s standard library. Add the following code to your main.go file:

func createFile(path string) error {
	file, err := os.Create(path)
	if err != nil {
		return err
	}
	defer file.Close()

	fmt.Printf("Created file: %s\n", path)
	return nil
}

Now, inside the case "create": block in the main() function, call the createFile() function:

err := createFile(*filePath)
if err != nil {
	fmt.Println("Error creating file:", err)
	os.Exit(1)
}

Read Operation

To read file contents, we can use the bufio package and its NewScanner function. Add the following code to your main.go file:

func readFile(path string) error {
	file, err := os.Open(path)
	if err != nil {
		return err
	}
	defer file.Close()

	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		fmt.Println(scanner.Text())
	}

	if err := scanner.Err(); err != nil {
		return err
	}

	return nil
}

Now, inside the case "read": block in the main() function, call the readFile() function:

err := readFile(*filePath)
if err != nil {
	fmt.Println("Error reading file:", err)
	os.Exit(1)
}

Update Operation

To update a file, we can use the ioutil package and its WriteFile function. Add the following code to your main.go file:

func updateFile(path string, content string) error {
	err := ioutil.WriteFile(path, []byte(content), 0644)
	if err != nil {
		return err
	}

	fmt.Printf("Updated file: %s\n", path)
	return nil
}

Now, inside the case "update": block in the main() function, call the updateFile() function:

err := updateFile(*filePath, "New file content")
if err != nil {
	fmt.Println("Error updating file:", err)
	os.Exit(1)
}

Delete Operation

To delete a file, we can use the os package and its Remove function. Add the following code to your main.go file:

func deleteFile(path string) error {
	err := os.Remove(path)
	if err != nil {
		return err
	}

	fmt.Printf("Deleted file: %s\n", path)
	return nil
}

Now, inside the case "delete": block in the main() function, call the deleteFile() function:

err := deleteFile(*filePath)
if err != nil {
	fmt.Println("Error deleting file:", err)
	os.Exit(1)
}

Conclusion

In this tutorial, we have learned how to build a CLI tool for file system operations using Go. We started by setting up our project, creating a basic CLI structure, and parsing command-line arguments. Then, we implemented file system operations such as create, read, update, and delete. You can further enhance this CLI tool by adding more operations or error handling. Experiment with different file system operations and explore the Go standard library for more functionalities.

Remember to always handle errors properly and ensure efficient resource usage when working with the file system. Happy coding!

Published:

Related Articles