File System

Introduction

In this comprehensive case study, we’ll design a File System from scratch using the systematic 8-step approach. This is a classic LLD interview problem that demonstrates hierarchical data structures, path navigation, and the powerful Composite Pattern.

Why This Problem?

File System is perfect for learning LLD because it involves:

• Hierarchical Structure - Directories containing files and subdirectories
• Key Design Patterns - Composite, Singleton
• Path Navigation - Parsing and traversing directory trees
• Real-world Complexity - Concurrency, edge cases, extensibility
• Clear Boundaries - Well-defined scope, familiar to everyone

---

Problem Statement

Design a File System that can:

• Support creating directories at any valid path
• Support creating files with content at any valid path
• Read file content by providing the file path
• Delete files and directories
• List all entries (files and directories) in a given directory
• Navigate through directory hierarchy using absolute paths (Unix-style)
• Prevent duplicate entries (cannot create a file if a directory exists at that path, and vice versa)
• Handle concurrent file operations from multiple users

---

Step 1: Clarify Requirements

Before designing, let’s ask the right questions!

Clarifying Questions

Functional Requirements:

1. Path Format: How should paths be represented? → Absolute paths starting with ’/’, using forward slashes as separators (e.g., /home/user/file.txt)
2. Directory Creation: Should parent directories be created automatically? → Yes, when creating files; optional when creating directories
3. Duplicate Prevention: What happens if we try to create a file where a directory exists? → Should return false/error, cannot create
4. File Updates: What happens if we create a file that already exists? → Update the content
5. Directory Updates: What happens if we create a directory that already exists? → Return true (no error, already exists)
6. Deletion: Can we delete directories with contents? → Yes, delete recursively or return error (clarify: for simplicity, assume empty directories only)

Non-Functional Requirements:

1. Concurrency: Multiple users can access/update simultaneously → Yes, thread safety needed
2. Scalability: How many files/directories? → Should handle thousands efficiently
3. Path Navigation: How fast should path resolution be? → O(depth) where depth is path length

Edge Cases to Consider:

• What if path doesn’t start with ’/’?
• What if path is empty or just ’/’?
• What if we try to navigate through a file (e.g., /home/file.txt/dir)?
• What if parent directory doesn’t exist?
• What if we try to delete root directory?
• What if multiple threads create the same path simultaneously?

Requirements Summary

---

Step 2: Identify Actors

Actors are external entities that interact with the system.

Who Uses This System?

Primary Actors:

1. User - Creates directories and files, reads file content, deletes entries, lists directory contents
2. System Administrator - (Future) Manages file system configuration, permissions, and quotas
3. Application - (Future) Automated processes that interact with the file system

Secondary Actors:

• Backup System - (Future) External system for data backup
• Search Service - (Future) Indexes files for search operations

Actor Interactions

Actor vs Entity

Actors are external users/systems that interact with your system. Entities are internal objects managed by the system. In this case:

• User (Actor) uses FileSystem (Entity)
• File and Directory are Entities, not Actors (they’re data structures, not users)

---

Step 3: Identify Entities

Entities are core objects in your system that have data and behavior.

The Noun Hunt

Looking at the requirements, we identify these core entities:

1. FileSystem - Main orchestrator, manages root directory
2. FileSystemEntry - Abstract base class for files and directories
3. File - Represents a file with content
4. Directory - Represents a directory containing entries
5. Path - (Implicit) String representation of location

Entity Relationships

---

Step 4: Assign Responsibilities

Each class should have a single, well-defined responsibility (SRP).

Responsibility Assignment

FileSystem:

• Manage root directory (Singleton pattern)
• Parse absolute paths into components
• Navigate through directory tree
• Coordinate file/directory operations (create, read, delete, list)
• Ensure thread safety for concurrent operations

FileSystemEntry:

• Define common interface for files and directories
• Store common properties (name, size)
• Provide type identification methods (isFile, isDirectory)
• Enable uniform treatment via Composite Pattern

File:

• Store file content
• Provide read/write operations
• Calculate file size based on content
• Thread-safe content access

Directory:

• Manage collection of FileSystemEntry objects
• Add/remove entries
• List all entries
• Update directory size
• Thread-safe entry management

Responsibility Visualization

[Single Responsibility Principle](/design-principles/solid-principles/00-single-responsibility-principle)

Each class should have one reason to change. For example:

• File changes only when file operations change
• Directory changes only when directory management changes
• FileSystem changes only when path navigation or orchestration changes

---

Step 5: Design Class Diagrams

Class diagrams show structure, relationships, and design patterns.

Complete Class Diagram

classDiagram
    class FileSystemEntry {
        <<abstract>>
        -String name
        -int size
        -Object lock
        +getName() String
        +getSize() int
        +setName(String) void
        +isFile() boolean*
        +isDirectory() boolean*
    }
    
    class File {
        -String content
        +read() String
        +write(String) void
        +append(String) void
        +isFile() boolean
        +isDirectory() boolean
    }
    
    class Directory {
        -Map~String,FileSystemEntry~ entries
        +addEntry(FileSystemEntry) void
        +removeEntry(String) void
        +getEntry(String) FileSystemEntry
        +listEntries() List~FileSystemEntry~
        +containsEntry(String) boolean
        -updateSize() void
        +isFile() boolean
        +isDirectory() boolean
    }
    
    class FileSystem {
        -Directory root
        -Object lock
        -static FileSystem instance
        +getInstance() FileSystem
        -parsePath(String) String[]
        -navigateToDirectory(String[], boolean) Directory
        +createDirectory(String) boolean
        +createFile(String, String) boolean
        +readFile(String) String
        +deleteEntry(String) boolean
        +listDirectory(String) List~String~
        +getRoot() Directory
    }
    
    FileSystemEntry <|-- File
    FileSystemEntry <|-- Directory
    FileSystem "1" *-- "1" Directory : root
    Directory "1" o-- "*" FileSystemEntry : entries

Design Patterns Used

1. Composite Pattern - FileSystemEntry, File, Directory

• Treats files and directories uniformly
• Enables recursive operations on directory tree
• Natural hierarchical structure

2. Singleton Pattern - FileSystem

• Ensures single file system instance
• Prevents data inconsistency
• Global access point

3. Inheritance - FileSystemEntry hierarchy

• Code reuse for common properties
• Polymorphism for different entry types

---

Step 6: Define Contracts & APIs

Contracts define how classes interact - method signatures, interfaces, and behavior.

Core Class Contracts

Python

FileSystemEntry:

file_system_entry.py

class FileSystemEntry(ABC):
    """
    Abstract base class for file system entries.
    Enables Composite Pattern for uniform treatment.
    """

    @abstractmethod
    def is_file(self) -> bool:
        """
        Check if this entry is a file.

        Returns:
            bool: True if file, False if directory
        """
        pass

    @abstractmethod
    def is_directory(self) -> bool:
        """
        Check if this entry is a directory.

        Returns:
            bool: True if directory, False if file
        """
        pass

    def get_name(self) -> str:
        """
        Get the name of this entry.

        Returns:
            str: Entry name
        """
        pass

    def get_size(self) -> int:
        """
        Get the size of this entry.

        Returns:
            int: Entry size
        """
        pass

FileSystem:

file_system.py

class FileSystem:
    @classmethod
    def get_instance(cls) -> 'FileSystem':
        """
        Get singleton instance of file system.

        Returns:
            FileSystem: The single instance
        """
        pass

    def create_directory(self, path: str) -> bool:
        """
        Create a directory at the specified path.

        Args:
            path: Absolute path (e.g., '/home/user/documents')

        Returns:
            bool: True if created successfully, False if path invalid or conflict exists

        Raises:
            ValueError: If path doesn't start with '/'
        """
        pass

    def create_file(self, path: str, content: str) -> bool:
        """
        Create a file with content at the specified path.
        Creates parent directories if they don't exist.

        Args:
            path: Absolute path (e.g., '/home/user/file.txt')
            content: File content

        Returns:
            bool: True if created successfully, False if path invalid or conflict exists
        """
        pass

    def read_file(self, path: str) -> Optional[str]:
        """
        Read content of a file.

        Args:
            path: Absolute path to file

        Returns:
            Optional[str]: File content if exists, None otherwise
        """
        pass

    def delete_entry(self, path: str) -> bool:
        """
        Delete a file or directory.

        Args:
            path: Absolute path to entry

        Returns:
            bool: True if deleted successfully, False if path invalid or doesn't exist
        """
        pass

    def list_directory(self, path: str) -> List[str]:
        """
        List all entries in a directory.

        Args:
            path: Absolute path to directory

        Returns:
            List[str]: List of entry names, empty list if directory doesn't exist
        """
        pass

Java

FileSystemEntry:

FileSystemEntry.java

abstract class FileSystemEntry {
    /**
     * Check if this entry is a file.
     * @return True if file, false if directory
     */
    public abstract boolean isFile();

    /**
     * Check if this entry is a directory.
     * @return True if directory, false if file
     */
    public abstract boolean isDirectory();

    /**
     * Get the name of this entry.
     * @return Entry name
     */
    public String getName();

    /**
     * Get the size of this entry.
     * @return Entry size
     */
    public int getSize();
}

FileSystem:

FileSystem.java

class FileSystem {
    /**
     * Get singleton instance of file system.
     * @return The single instance
     */
    public static FileSystem getInstance();

    /**
     * Create a directory at the specified path.
     * @param path Absolute path (e.g., "/home/user/documents")
     * @return True if created successfully, false if path invalid or conflict exists
     * @throws IllegalArgumentException If path doesn't start with '/'
     */
    public boolean createDirectory(String path);

    /**
     * Create a file with content at the specified path.
     * Creates parent directories if they don't exist.
     * @param path Absolute path (e.g., "/home/user/file.txt")
     * @param content File content
     * @return True if created successfully, false if path invalid or conflict exists
     */
    public boolean createFile(String path, String content);

    /**
     * Read content of a file.
     * @param path Absolute path to file
     * @return File content if exists, null otherwise
     */
    public String readFile(String path);

    /**
     * Delete a file or directory.
     * @param path Absolute path to entry
     * @return True if deleted successfully, false if path invalid or doesn't exist
     */
    public boolean deleteEntry(String path);

    /**
     * List all entries in a directory.
     * @param path Absolute path to directory
     * @return List of entry names, empty list if directory doesn't exist
     */
    public List<String> listDirectory(String path);
}

Contract Visualization

Contract [Design Principles](/design-principles/00-introduction-to-design-principles)

• Be explicit - Clear parameter types and return types
• Document edge cases - What happens with invalid paths?
• Keep it simple - Don’t over-complicate
• Think about callers - What do they need?

---

Step 7: Handle Edge Cases

Edge cases are scenarios that might not be obvious but are important to handle.

Critical Edge Cases

1. Invalid Path Format

• Path doesn’t start with ’/’ → Return false/null
• Empty path or just ’/’ → Return false/null
• Path with multiple consecutive slashes → Normalize to single slashes
• Trailing slashes → Handle gracefully

2. Path Navigation Through Files

• Attempting to navigate through a file (e.g., /home/file.txt/dir) → Return null
• Files are leaf nodes, cannot contain other entries

3. Duplicate Entry Prevention

• Creating file where directory exists → Return false
• Creating directory where file exists → Return false
• Creating file that already exists → Update content, return true
• Creating directory that already exists → Return true (no error)

4. Non-existent Paths

• Reading file that doesn’t exist → Return null
• Deleting entry that doesn’t exist → Return false
• Listing non-existent directory → Return empty list

5. Root Directory Protection

• Cannot create/delete root directory → Return false
• Root is special, must always exist

6. Concurrent Access

• Multiple threads creating same path → Thread-safe operations prevent race conditions
• One thread reading while another writing → Synchronized access

Edge Case Handling Flow

Thread Safety Considerations

Python

thread_safe_file_system.py

# Simplified thread-safe file system
class FileSystem:
    def __init__(self):
        self._lock = threading.Lock()
        self.root = Directory("root")

    def create_file(self, path: str, content: str) -> bool:
        with self._lock:  # Critical section
            path_parts = self._parse_path(path)
            if not path_parts:
                return False

            parent_parts = path_parts[:-1]
            file_name = path_parts[-1]

            parent = self._navigate_to_directory(parent_parts, True)
            if parent is None:
                return False

            # Check for conflicts
            if parent.contains_entry(file_name):
                existing = parent.get_entry(file_name)
                if existing.is_directory():
                    return False  # Directory exists

            # Create file
            new_file = File(file_name)
            new_file.write(content)
            parent.add_entry(new_file)
            return True

Java

ThreadSafeFileSystem.java

// Simplified thread-safe file system
class FileSystem {
    private final ReentrantLock lock = new ReentrantLock();
    private Directory root = new Directory("root");

    public boolean createFile(String path, String content) {
        lock.lock(); // Critical section
        try {
            String[] pathParts = parsePath(path);
            if (pathParts.length == 0) {
                return false;
            }

            String[] parentParts = Arrays.copyOf(pathParts, pathParts.length - 1);
            String fileName = pathParts[pathParts.length - 1];

            Directory parent = navigateToDirectory(parentParts, true);
            if (parent == null) {
                return false;
            }

            // Check for conflicts
            if (parent.containsEntry(fileName)) {
                FileSystemEntry existing = parent.getEntry(fileName);
                if (existing.isDirectory()) {
                    return false; // Directory exists
                }
            }

            // Create file
            File newFile = new File(fileName);
            newFile.write(content);
            parent.addEntry(newFile);
            return true;
        } finally {
            lock.unlock();
        }
    }
}

Edge Case Checklist

Always think about:

• What if path is invalid?
• What if entry doesn’t exist?
• What if entry exists but wrong type?
• What if multiple users?
• What if concurrent access?
• What if path navigation fails?

---

Step 8: Code Implementation

Finally, implement your design following SOLID principles and design patterns.

Complete Implementation

Python

file_system_complete.py

from abc import ABC, abstractmethod
from threading import Lock
from typing import Optional, List, Dict

# =====================
# CORE ENTITIES
# =====================

class FileSystemEntry(ABC):
    """Abstract base class for file system entries (Composite Pattern)."""

    def __init__(self, name: str):
        self.name = name
        self.size = 0
        self.lock = Lock()

    def get_name(self) -> str:
        with self.lock:
            return self.name

    def get_size(self) -> int:
        with self.lock:
            return self.size

    def set_name(self, name: str):
        with self.lock:
            self.name = name

    @abstractmethod
    def is_file(self) -> bool:
        pass

    @abstractmethod
    def is_directory(self) -> bool:
        pass

class File(FileSystemEntry):
    """Represents a file in the file system (Leaf node)."""

    def __init__(self, name: str):
        super().__init__(name)
        self.content = ""

    def read(self) -> str:
        with self.lock:
            return self.content

    def write(self, data: str):
        with self.lock:
            self.content = data
            self.size = len(self.content)

    def append(self, data: str):
        with self.lock:
            self.content += data
            self.size = len(self.content)

    def is_file(self) -> bool:
        return True

    def is_directory(self) -> bool:
        return False

class Directory(FileSystemEntry):
    """Represents a directory in the file system (Composite node)."""

    def __init__(self, name: str):
        super().__init__(name)
        self.entries: Dict[str, FileSystemEntry] = {}

    def add_entry(self, entry: FileSystemEntry):
        with self.lock:
            self.entries[entry.get_name()] = entry
            self._update_size()

    def remove_entry(self, name: str):
        with self.lock:
            if name in self.entries:
                del self.entries[name]
                self._update_size()

    def get_entry(self, name: str) -> Optional[FileSystemEntry]:
        with self.lock:
            return self.entries.get(name)

    def list_entries(self) -> List[FileSystemEntry]:
        with self.lock:
            return list(self.entries.values())

    def contains_entry(self, name: str) -> bool:
        with self.lock:
            return name in self.entries

    def _update_size(self):
        self.size = len(self.entries)

    def is_file(self) -> bool:
        return False

    def is_directory(self) -> bool:
        return True

# =====================
# SINGLETON PATTERN - MAIN SYSTEM
# =====================

class FileSystem:
    """Main file system (Singleton)."""

    _instance = None
    _lock = Lock()

    def __new__(cls):
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
        return cls._instance

    def __init__(self):
        if hasattr(self, '_initialized'):
            return
        self.root = Directory("root")
        self.lock = Lock()
        self._initialized = True

    @classmethod
    def get_instance(cls):
        return cls()

    def _parse_path(self, path: str) -> List[str]:
        """Parse absolute path into components."""
        if not path or not path.startswith("/"):
            return []
        parts = path.split("/")
        return [part for part in parts if part]

    def _navigate_to_directory(self, path_parts: List[str], create_if_not_exists: bool) -> Optional[Directory]:
        """Navigate to directory, creating intermediate directories if needed."""
        with self.lock:
            current = self.root

            for part in path_parts:
                entry = current.get_entry(part)

                if entry is None:
                    if create_if_not_exists:
                        new_dir = Directory(part)
                        current.add_entry(new_dir)
                        current = new_dir
                    else:
                        return None
                elif entry.is_directory():
                    current = entry
                else:
                    return None  # Path contains a file, cannot navigate further

            return current

    def create_directory(self, path: str) -> bool:
        """Create a directory at the specified path."""
        with self.lock:
            path_parts = self._parse_path(path)
            if not path_parts:
                return False  # Cannot create root

            parent_parts = path_parts[:-1]
            dir_name = path_parts[-1]

            parent = self._navigate_to_directory(parent_parts, True)
            if parent is None:
                return False

            if parent.contains_entry(dir_name):
                existing = parent.get_entry(dir_name)
                if existing.is_file():
                    return False  # File exists at this path
                return True  # Directory already exists

            new_dir = Directory(dir_name)
            parent.add_entry(new_dir)
            return True

    def create_file(self, path: str, content: str) -> bool:
        """Create a file with content at the specified path."""
        with self.lock:
            path_parts = self._parse_path(path)
            if not path_parts:
                return False  # Cannot create file at root

            parent_parts = path_parts[:-1]
            file_name = path_parts[-1]

            parent = self._navigate_to_directory(parent_parts, True)
            if parent is None:
                return False

            if parent.contains_entry(file_name):
                existing = parent.get_entry(file_name)
                if existing.is_directory():
                    return False  # Directory exists at this path
                # File exists, update content
                file = existing
                file.write(content)
                return True

            new_file = File(file_name)
            new_file.write(content)
            parent.add_entry(new_file)
            return True

    def read_file(self, path: str) -> Optional[str]:
        """Read content of a file."""
        with self.lock:
            path_parts = self._parse_path(path)
            if not path_parts:
                return None

            parent_parts = path_parts[:-1]
            file_name = path_parts[-1]

            parent = self._navigate_to_directory(parent_parts, False)
            if parent is None:
                return None

            entry = parent.get_entry(file_name)
            if entry is None or not entry.is_file():
                return None

            return entry.read()

    def delete_entry(self, path: str) -> bool:
        """Delete a file or directory."""
        with self.lock:
            path_parts = self._parse_path(path)
            if not path_parts:
                return False  # Cannot delete root

            parent_parts = path_parts[:-1]
            entry_name = path_parts[-1]

            parent = self._navigate_to_directory(parent_parts, False)
            if parent is None:
                return False

            if not parent.contains_entry(entry_name):
                return False

            parent.remove_entry(entry_name)
            return True

    def list_directory(self, path: str) -> List[str]:
        """List all entries in a directory."""
        with self.lock:
            path_parts = self._parse_path(path)
            dir_obj = self._navigate_to_directory(path_parts, False)

            if dir_obj is None:
                return []

            return [entry.get_name() for entry in dir_obj.list_entries()]

    def get_root(self) -> Directory:
        return self.root

# =====================
# DEMO
# =====================

if __name__ == "__main__":
    fs = FileSystem.get_instance()

    print("=== File System Demo ===\n")

    # Create directories
    print("Creating directories...")
    print(f"Created /home: {fs.create_directory('/home')}")
    print(f"Created /home/user: {fs.create_directory('/home/user')}")
    print(f"Created /home/user/documents: {fs.create_directory('/home/user/documents')}")

    # Create files
    print("\nCreating files...")
    print(f"Created /home/user/file1.txt: {fs.create_file('/home/user/file1.txt', 'Hello, World!')}")
    print(f"Created /home/user/documents/readme.txt: {fs.create_file('/home/user/documents/readme.txt', 'This is a readme file.')}")

    # Read files
    print("\nReading files...")
    print(f"/home/user/file1.txt: {fs.read_file('/home/user/file1.txt')}")
    print(f"/home/user/documents/readme.txt: {fs.read_file('/home/user/documents/readme.txt')}")

    # List directory
    print("\nListing /home/user:")
    entries = fs.list_directory("/home/user")
    for entry in entries:
        print(f"  - {entry}")

    # Try to create duplicate
    print("\nTrying to create directory where file exists:")
    print(f"Created /home/user/file1.txt (as dir): {fs.create_directory('/home/user/file1.txt')}")

    # Delete entry
    print("\nDeleting /home/user/file1.txt:")
    print(f"Deleted: {fs.delete_entry('/home/user/file1.txt')}")
    print(f"Read after delete: {fs.read_file('/home/user/file1.txt')}")

    print("\n=== Demo Complete ===")

Java

FileSystemComplete.java

import java.util.*;
import java.util.concurrent.*;

// =====================
// CORE ENTITIES
// =====================

abstract class FileSystemEntry {
    protected String name;
    protected int size;
    protected final Object lock = new Object();

    public FileSystemEntry(String name) {
        this.name = name;
        this.size = 0;
    }

    public String getName() {
        synchronized (lock) {
            return name;
        }
    }

    public int getSize() {
        synchronized (lock) {
            return size;
        }
    }

    public void setName(String name) {
        synchronized (lock) {
            this.name = name;
        }
    }

    public abstract boolean isFile();
    public abstract boolean isDirectory();
}

class File extends FileSystemEntry {
    private StringBuilder content;

    public File(String name) {
        super(name);
        this.content = new StringBuilder();
    }

    public String read() {
        synchronized (lock) {
            return content.toString();
        }
    }

    public void write(String data) {
        synchronized (lock) {
            content = new StringBuilder(data);
            size = content.length();
        }
    }

    public void append(String data) {
        synchronized (lock) {
            content.append(data);
            size = content.length();
        }
    }

    @Override
    public boolean isFile() {
        return true;
    }

    @Override
    public boolean isDirectory() {
        return false;
    }
}

class Directory extends FileSystemEntry {
    private Map<String, FileSystemEntry> entries;

    public Directory(String name) {
        super(name);
        this.entries = new ConcurrentHashMap<>();
    }

    public void addEntry(FileSystemEntry entry) {
        synchronized (lock) {
            entries.put(entry.getName(), entry);
            updateSize();
        }
    }

    public void removeEntry(String name) {
        synchronized (lock) {
            entries.remove(name);
            updateSize();
        }
    }

    public FileSystemEntry getEntry(String name) {
        synchronized (lock) {
            return entries.get(name);
        }
    }

    public List<FileSystemEntry> listEntries() {
        synchronized (lock) {
            return new ArrayList<>(entries.values());
        }
    }

    public boolean containsEntry(String name) {
        synchronized (lock) {
            return entries.containsKey(name);
        }
    }

    private void updateSize() {
        size = entries.size();
    }

    @Override
    public boolean isFile() {
        return false;
    }

    @Override
    public boolean isDirectory() {
        return true;
    }
}

// =====================
// SINGLETON PATTERN - MAIN SYSTEM
// =====================

class FileSystem {
    private static FileSystem instance;
    private Directory root;
    private final Object lock = new Object();

    private FileSystem() {
        this.root = new Directory("root");
    }

    public static FileSystem getInstance() {
        if (instance == null) {
            synchronized (FileSystem.class) {
                if (instance == null) {
                    instance = new FileSystem();
                }
            }
        }
        return instance;
    }

    private String[] parsePath(String path) {
        if (path == null || path.isEmpty() || !path.startsWith("/")) {
            return new String[0];
        }
        String[] parts = path.split("/");
        List<String> result = new ArrayList<>();
        for (String part : parts) {
            if (!part.isEmpty()) {
                result.add(part);
            }
        }
        return result.toArray(new String[0]);
    }

    private Directory navigateToDirectory(String[] pathParts, boolean createIfNotExists) {
        synchronized (lock) {
            Directory current = root;

            for (int i = 0; i < pathParts.length; i++) {
                String part = pathParts[i];
                FileSystemEntry entry = current.getEntry(part);

                if (entry == null) {
                    if (createIfNotExists) {
                        Directory newDir = new Directory(part);
                        current.addEntry(newDir);
                        current = newDir;
                    } else {
                        return null;
                    }
                } else if (entry.isDirectory()) {
                    current = (Directory) entry;
                } else {
                    return null; // Path contains a file, cannot navigate further
                }
            }

            return current;
        }
    }

    public boolean createDirectory(String path) {
        synchronized (lock) {
            String[] pathParts = parsePath(path);
            if (pathParts.length == 0) {
                return false; // Cannot create root
            }

            String[] parentParts = Arrays.copyOf(pathParts, pathParts.length - 1);
            String dirName = pathParts[pathParts.length - 1];

            Directory parent = navigateToDirectory(parentParts, true);
            if (parent == null) {
                return false;
            }

            if (parent.containsEntry(dirName)) {
                FileSystemEntry existing = parent.getEntry(dirName);
                if (existing.isFile()) {
                    return false; // File exists at this path
                }
                return true; // Directory already exists
            }

            Directory newDir = new Directory(dirName);
            parent.addEntry(newDir);
            return true;
        }
    }

    public boolean createFile(String path, String content) {
        synchronized (lock) {
            String[] pathParts = parsePath(path);
            if (pathParts.length == 0) {
                return false; // Cannot create file at root
            }

            String[] parentParts = Arrays.copyOf(pathParts, pathParts.length - 1);
            String fileName = pathParts[pathParts.length - 1];

            Directory parent = navigateToDirectory(parentParts, true);
            if (parent == null) {
                return false;
            }

            if (parent.containsEntry(fileName)) {
                FileSystemEntry existing = parent.getEntry(fileName);
                if (existing.isDirectory()) {
                    return false; // Directory exists at this path
                }
                // File exists, update content
                File file = (File) existing;
                file.write(content);
                return true;
            }

            File newFile = new File(fileName);
            newFile.write(content);
            parent.addEntry(newFile);
            return true;
        }
    }

    public String readFile(String path) {
        synchronized (lock) {
            String[] pathParts = parsePath(path);
            if (pathParts.length == 0) {
                return null;
            }

            String[] parentParts = Arrays.copyOf(pathParts, pathParts.length - 1);
            String fileName = pathParts[pathParts.length - 1];

            Directory parent = navigateToDirectory(parentParts, false);
            if (parent == null) {
                return null;
            }

            FileSystemEntry entry = parent.getEntry(fileName);
            if (entry == null || !entry.isFile()) {
                return null;
            }

            return ((File) entry).read();
        }
    }

    public boolean deleteEntry(String path) {
        synchronized (lock) {
            String[] pathParts = parsePath(path);
            if (pathParts.length == 0) {
                return false; // Cannot delete root
            }

            String[] parentParts = Arrays.copyOf(pathParts, pathParts.length - 1);
            String entryName = pathParts[pathParts.length - 1];

            Directory parent = navigateToDirectory(parentParts, false);
            if (parent == null) {
                return false;
            }

            if (!parent.containsEntry(entryName)) {
                return false;
            }

            parent.removeEntry(entryName);
            return true;
        }
    }

    public List<String> listDirectory(String path) {
        synchronized (lock) {
            String[] pathParts = parsePath(path);
            Directory dir = navigateToDirectory(pathParts, false);

            if (dir == null) {
                return new ArrayList<>();
            }

            List<String> result = new ArrayList<>();
            for (FileSystemEntry entry : dir.listEntries()) {
                result.add(entry.getName());
            }
            return result;
        }
    }

    public Directory getRoot() {
        return root;
    }
}

// =====================
// DEMO
// =====================

public class FileSystemDemo {
    public static void main(String[] args) {
        FileSystem fs = FileSystem.getInstance();

        System.out.println("=== File System Demo ===\n");

        // Create directories
        System.out.println("Creating directories...");
        System.out.println("Created /home: " + fs.createDirectory("/home"));
        System.out.println("Created /home/user: " + fs.createDirectory("/home/user"));
        System.out.println("Created /home/user/documents: " + fs.createDirectory("/home/user/documents"));

        // Create files
        System.out.println("\nCreating files...");
        System.out.println("Created /home/user/file1.txt: " +
            fs.createFile("/home/user/file1.txt", "Hello, World!"));
        System.out.println("Created /home/user/documents/readme.txt: " +
            fs.createFile("/home/user/documents/readme.txt", "This is a readme file."));

        // Read files
        System.out.println("\nReading files...");
        System.out.println("/home/user/file1.txt: " + fs.readFile("/home/user/file1.txt"));
        System.out.println("/home/user/documents/readme.txt: " +
            fs.readFile("/home/user/documents/readme.txt"));

        // List directory
        System.out.println("\nListing /home/user:");
        List<String> entries = fs.listDirectory("/home/user");
        for (String entry : entries) {
            System.out.println("  - " + entry);
        }

        // Try to create duplicate
        System.out.println("\nTrying to create directory where file exists:");
        System.out.println("Created /home/user/file1.txt (as dir): " +
            fs.createDirectory("/home/user/file1.txt"));

        // Delete entry
        System.out.println("\nDeleting /home/user/file1.txt:");
        System.out.println("Deleted: " + fs.deleteEntry("/home/user/file1.txt"));
        System.out.println("Read after delete: " + fs.readFile("/home/user/file1.txt"));

        System.out.println("\n=== Demo Complete ===");
    }
}

Key Implementation Highlights

1. Composite Pattern:

• FileSystemEntry as common interface
• File as leaf node
• Directory as composite node containing FileSystemEntry objects

2. Singleton Pattern:

• Single FileSystem instance
• Thread-safe double-checked locking

3. Path Navigation:

• Parse paths into components
• Navigate directory tree efficiently
• Create intermediate directories automatically

4. Thread Safety:

• Synchronized blocks for critical sections
• Concurrent collections for directory entries
• Fine-grained locking at each level

---

Design Patterns Deep Dive

Why Composite Pattern?

Problem: Files and directories need to be treated uniformly, but directories can contain other entries.

Without Composite:

Python

composite_bad.py

# Separate handling for files and directories
def list_directory(path):
    if is_file(path):
        return []  # Files don't have contents
    elif is_directory(path):
        entries = []
        for entry in get_directory_entries(path):
            if is_file(entry):
                entries.append(entry.name)
            elif is_directory(entry):
                entries.append(entry.name + "/")
        return entries
# Type checking everywhere ❌

Java

CompositeBad.java

// Separate handling for files and directories
public List<String> listDirectory(String path) {
    if (isFile(path)) {
        return Collections.emptyList(); // Files don't have contents
    } else if (isDirectory(path)) {
        List<String> entries = new ArrayList<>();
        for (Entry entry : getDirectoryEntries(path)) {
            if (entry instanceof File) {
                entries.add(entry.getName());
            } else if (entry instanceof Directory) {
                entries.add(entry.getName() + "/");
            }
        }
        return entries;
    }
    // Type checking everywhere ❌
}

With Composite:

Python

composite_good.py

# Uniform treatment
def list_directory(path):
    dir_obj = navigate_to_directory(path)
    if dir_obj is None:
        return []

    return [entry.get_name() for entry in dir_obj.list_entries()]
# Works uniformly for all FileSystemEntry objects ✅

Java

CompositeGood.java

// Uniform treatment
public List<String> listDirectory(String path) {
    Directory dir = navigateToDirectory(path);
    if (dir == null) {
        return Collections.emptyList();
    }

    return dir.listEntries().stream()
        .map(FileSystemEntry::getName)
        .collect(Collectors.toList());
    // Works uniformly for all FileSystemEntry objects ✅
}

Benefits:

• Uniform Treatment - Code works with FileSystemEntry without type checking
• Recursive Operations - Easy to implement recursive operations (e.g., total size)
• Extensibility - Add new entry types (e.g., SymbolicLink) without changing existing code
• Natural Structure - Mirrors real file system hierarchy

Why Singleton Pattern?

Problem: Multiple instances would cause data inconsistency.

Without Singleton:

Python

singleton_bad.py

# Process A
fs_a = FileSystem()  # Creates /home/user/file.txt
fs_a.create_file("/home/user/file.txt", "content")

# Process B (different instance!)
fs_b = FileSystem()  # Doesn't see file.txt
fs_b.read_file("/home/user/file.txt")  # Returns None - INCONSISTENCY!

Java

SingletonBad.java

// Process A
FileSystem fsA = new FileSystem(); // Creates /home/user/file.txt
fsA.createFile("/home/user/file.txt", "content");

// Process B (different instance!)
FileSystem fsB = new FileSystem(); // Doesn't see file.txt
fsB.readFile("/home/user/file.txt"); // Returns null - INCONSISTENCY!

With Singleton:

Python

singleton_good.py

# Process A
fs_a = FileSystem.get_instance()  # Same instance
fs_a.create_file("/home/user/file.txt", "content")

# Process B
fs_b = FileSystem.get_instance()  # Same instance!
fs_b.read_file("/home/user/file.txt")  # Returns "content" - CONSISTENT!

Java

SingletonGood.java

// Process A
FileSystem fsA = FileSystem.getInstance(); // Same instance
fsA.createFile("/home/user/file.txt", "content");

// Process B
FileSystem fsB = FileSystem.getInstance(); // Same instance!
fsB.readFile("/home/user/file.txt"); // Returns "content" - CONSISTENT!

---

System Flow Diagrams

Create File Flow

Read File Flow

---

Extensibility & Future Enhancements

Easy to Extend

1. Add New Entry Type (Symbolic Link):

Python

symbolic_link.py

class SymbolicLink(FileSystemEntry):
    """Represents a symbolic link."""

    def __init__(self, name: str, target_path: str):
        super().__init__(name)
        self.target_path = target_path

    def get_target(self) -> str:
        return self.target_path

    def is_file(self) -> bool:
        return False  # Symbolic links are neither files nor directories

    def is_directory(self) -> bool:
        return False

Java

SymbolicLink.java

class SymbolicLink extends FileSystemEntry {
    private String targetPath;

    public SymbolicLink(String name, String targetPath) {
        super(name);
        this.targetPath = targetPath;
    }

    public String getTarget() {
        return targetPath;
    }

    @Override
    public boolean isFile() {
        return false; // Symbolic links are neither files nor directories
    }

    @Override
    public boolean isDirectory() {
        return false;
    }
}

2. Add File Permissions:

Python

permissions.py

class FileSystemEntry(ABC):
    def __init__(self, name: str):
        self.name = name
        self.size = 0
        self.permissions = Permissions.READ_WRITE  # New field
        self.owner = "root"  # New field

Java

Permissions.java

abstract class FileSystemEntry {
    protected String name;
    protected int size;
    protected Permissions permissions = Permissions.READ_WRITE; // New field
    protected String owner = "root"; // New field
}

3. Add Metadata:

Python

metadata.py

class FileSystemEntry(ABC):
    def __init__(self, name: str):
        self.name = name
        self.size = 0
        self.created_date = datetime.now()  # New field
        self.modified_date = datetime.now()  # New field

Java

Metadata.java

abstract class FileSystemEntry {
    protected String name;
    protected int size;
    protected Date createdDate = new Date(); // New field
    protected Date modifiedDate = new Date(); // New field
}

Future Enhancements

1. Recursive Operations:

• Add getTotalSize() method that recursively calculates directory size
• Add searchFiles(String pattern) method for file search

2. Copy/Move Operations:

• Add copyEntry(String source, String dest) method
• Add moveEntry(String source, String dest) method

3. Persistence:

• Add save() and load() methods to serialize to disk
• Support loading file system state from storage

4. Advanced Features:

• File locking for concurrent writes
• Directory quotas
• File versioning
• Access control lists (ACL)

---

Summary

Key Takeaways

• Follow Systematic Approach - Don’t jump to code
• Identify Actors First - Who uses the system?
• Identify Entities - What are the core objects?
• Assign Responsibilities - Single Responsibility Principle
• Design Class Diagrams - Visualize structure and relationships
• Define Contracts - Clear interfaces and APIs
• Handle Edge Cases - Think about errors and concurrency
• Use Design Patterns - Composite, Singleton
• Make it Extensible - Easy to add new features

Design Patterns Used

1. Composite Pattern - Uniform treatment of files and directories
2. Singleton Pattern - Single file system instance
3. Inheritance - FileSystemEntry hierarchy

Best Practices Demonstrated

• SOLID principles (SRP, OCP)
• Thread safety considerations
• Clear separation of concerns
• Extensible design
• Error handling
• Clean code structure
• Path navigation efficiency

---

Next Steps

Now that you’ve mastered the File System:

Practice Similar Problems:

• Parking Lot System
• Elevator System
• Library Management System
• Directory Tree Traversal

Explore More Patterns:

• Observer Pattern (for file system events)
• Command Pattern (for undo/redo operations)
• Visitor Pattern (for recursive operations)

Deepen Your Understanding:

• Study real file systems (ext4, NTFS)
• Learn about inodes and directory structures
• Explore distributed file systems
• Study file system caching strategies

---

Practice Makes Perfect

Try implementing this system yourself! Start with the basic version, then add:

• Recursive directory deletion
• File search functionality
• Copy/move operations
• File permissions

The more you practice, the better you’ll become at LLD interviews! 🚀