Trabalho_Prático_SO__Sistema_de_Arquivos

Main.java

@@ -1,20 +1,25 @@
 import filesys.IFileSystem;
+import filesys.Offset;
+import filesys.Usuario;
+import filesys.FileSystem;
 
 import java.util.Scanner;
 import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.List;
 
 import exception.PermissaoException;
 import exception.CaminhoJaExistenteException;
 import exception.CaminhoNaoEncontradoException;
 
-import filesys.FileSystem;
-
-// MENU INTERATIVO PARA O SISTEMA DE ARQUIVOS
-// SINTA-SE LIVRE PARA ALTERAR A CLASSE MAIN
+/*
+ MENU INTERATIVO PARA O SISTEMA DE ARQUIVOS
+ SINTA-SE LIVRE PARA ALTERAR A CLASSE MAIN
+*/
 public class Main {
 
-    // Constantes úteis para a versão interativa. 
-    // Para esse tipo de execução, o tamanho max do buffer de 
+    // Constantes úteis para a versão interativa.
+    // Para esse tipo de execução, o tamanho max do buffer de
     // leitura pode ser menor.
     private static final String ROOT_USER = "root";
     private static final String ROOT_DIR = "/";
@@ -29,30 +34,21 @@ public class Main {
     // Usuário que está executando o programa
     private static String user;
 
-    // O sistema de arquivos é inteiramente virtual, ou seja, será reiniciado a cada execução do programa.
-    // Logo, não é necessário salvar os arquivos em disco. O sistema será uma simulação em memória.
+    // O sistema de arquivos é inteiramente virtual, ou seja, será reiniciado a cada
+    // execução do programa.
+    // Logo, não é necessário salvar os arquivos em disco. O sistema será uma
+    // simulação em memória.
     public static void main(String[] args) {
-        // Usuário que está executando o programa.
-        // Para quaisquer operações que serão feitas por esse usuário em um caminho /path/**,
-        // deve-se checar se o usuário tem permissão de escrita (r) neste caminho.
         if (args.length < 2) {
             System.out.println("Usuário não fornecido");
             return;
         }
         user = args[1];
-        
+
         // Carrega a lista de usuários do sistema a partir de arquivo
-        // Formato do arquivo users:
-        //      username dir permission
-        // Exemplo:
-        //      maria /** rw-
-        //      luzia /** rwx
-        // Essa permissão vale para o diretório raiz e sub diretórios.
-        // A partir do momento que um usuário cria outro diretório ou arquivo, 
-        // a permissão desse usuário é de leitura, escrita e execução nesse novo diretório/arquivo,
-        // e sempre será rwx para o usuário root.
+        List<Usuario> usuarios = new ArrayList<>();
         try {
-            Scanner userScanner = new Scanner(new java.io.File("users/users"));
+            Scanner userScanner = new Scanner(new java.io.File("users/userMkdir"));
             while (userScanner.hasNextLine()) {
                 String line = userScanner.nextLine().trim();
                 if (!line.isEmpty()) {
@@ -61,46 +57,44 @@ public static void main(String[] args) {
                         String userListed = parts[0];
                         String dir = parts[1];
                         String dirPermission = parts[2];
-
-                        /* A FAZER:
-                         * Processar a permissão de todos os usuários existentes por diretório.
-                         * Por enquanto esse código somente imprime as permissões contidas no arquivo users.
-                        */
-                        System.out.println(userListed + " " + dir + " " + dirPermission); // Somente imprime o usuário, diretório e permissão
-
-
+                        usuarios.add(new Usuario(userListed, dirPermission, dir));
                     } else {
                         System.out.println("Formato ruim no arquivo de usuários. Linha: " + line);
                     }
                 }
             }
             userScanner.close();
-        } catch (FileNotFoundException e) { // Retorna se o arquivo de usuários não for encontrado
+        } catch (FileNotFoundException e) {
             System.out.println("Arquivo de usuários não encontrado");
-
             return;
         }
-
-        // Finalmente cria o Sistema de Arquivos
-        // Lista de usuários é imutável durante a execução do programa
-        // Obs: Como passar a lista de usuários para o FileSystem?
-        fileSystem = new FileSystem(/*usuários?*/);
-
-        // // DESCOMENTE O BLOCO ABAIXO PARA CRIAR O DIRETÓRIO RAIZ ANTES DE RODAR O MENU
-        // // Cria o diretório raiz do sistema. Root sempre tem permissão total "rwx"
-        // try {
-        //     fileSystem.mkdir(ROOT_DIR, ROOT_USER);
-        // } catch (CaminhoJaExistenteException | PermissaoException e) {
-        //     System.out.println(e.getMessage());
-        // }
+
+        // Inicializa o sistema de arquivos com a lista de usuários
+        fileSystem = new FileSystem(usuarios);
+
+        // Cria os diretórios e aplica as permissões conforme o arquivo
+        for (Usuario usuario : usuarios) {
+            try {
+                fileSystem.mkdir(usuario.getDiretorio(), usuario.getNome());
+                // Aplica a permissão do arquivo para o usuário no diretório criado
+                fileSystem.chmod(usuario.getDiretorio(), "root", usuario.getNome(), usuario.getPermissao());
+            } catch (CaminhoJaExistenteException | PermissaoException | CaminhoNaoEncontradoException e) {
+                // Se já existe, não tem permissão ou não encontra, apenas ignore
+            }
+        }
+
+        // Cria o diretório raiz do sistema (caso não exista)
+        try {
+            fileSystem.mkdir(ROOT_DIR, ROOT_USER);
+        } catch (CaminhoJaExistenteException | PermissaoException e) {
+            // Pode ignorar se já existe
+        }
 
         // Menu interativo.
         menu();
     }
 
-    // Menu interativo para fins de teste.
-    // Os testes junit não são feitos com esse menu,
-    // mas diretamente na interface IFileSystem
+    // … o resto de Main fica inalterado, igual ao que você já tinha …
     public static void menu() {
         while (true) {
             System.out.println("\nComandos disponíveis:");
@@ -148,11 +142,10 @@ public static void menu() {
                         break;
                     case "0":
                         System.out.println("Encerrando...");
-
                         return;
                     default:
                         System.out.println("Comando inválido!");
-                } 
+                }
             } catch (CaminhoNaoEncontradoException | CaminhoJaExistenteException | PermissaoException e) {
                 System.out.println("Erro: " + e.getMessage());
             }
@@ -169,16 +162,16 @@ public static void chmod() throws CaminhoNaoEncontradoException, PermissaoExcept
         String caminho = scanner.nextLine();
         System.out.println("Insira o usuário para o qual deseja alterar as permissões:");
         String usuarioAlvo = scanner.nextLine();
-        System.out.println("Insira a permissão (formato: 3 caracteres\"rwx\"):");
+        System.out.println("Insira a permissão (formato: 3 caracteres\"rwx\"): ");
         String permissoes = scanner.nextLine();
-        
+
         fileSystem.chmod(caminho, user, usuarioAlvo, permissoes);
     }
 
     public static void mkdir() throws CaminhoJaExistenteException, PermissaoException {
         System.out.println("Insira o caminho do diretório a ser criado:");
         String caminho = scanner.nextLine();
-        
+
         fileSystem.mkdir(caminho, user);
     }
 
@@ -187,14 +180,14 @@ public static void rm() throws CaminhoNaoEncontradoException, PermissaoException
         String caminho = scanner.nextLine();
         System.out.println("Remover recursivamente? (true/false):");
         boolean recursivo = Boolean.parseBoolean(scanner.nextLine());
-        
+
         fileSystem.rm(caminho, user, recursivo);
     }
 
     public static void touch() throws CaminhoJaExistenteException, PermissaoException {
         System.out.println("Insira o caminho do arquivo a ser criado:");
         String caminho = scanner.nextLine();
-        
+
         fileSystem.touch(caminho, user);
     }
 
@@ -206,24 +199,37 @@ public static void write() throws CaminhoNaoEncontradoException, PermissaoExcept
         System.out.println("Insira o conteúdo a ser escrito:");
         String content = scanner.nextLine();
         byte[] buffer = content.getBytes();
-        
+
         fileSystem.write(caminho, user, anexar, buffer);
     }
 
     public static void read() throws CaminhoNaoEncontradoException, PermissaoException {
         System.out.println("Insira o caminho do arquivo a ser lido:");
         String caminho = scanner.nextLine();
-        byte[] buffer = new byte[READ_BUFFER_SIZE]; // Exemplo de tamanho de buffer por load/leitura . O que acontece se o Buffer for menor que o conteúdo a ser lido?     
-
-        fileSystem.read(caminho, user, buffer); // Lógica para ler arquivos maiores que o buffer deve ser implementada. 
+        byte[] buffer = new byte[READ_BUFFER_SIZE];
+
+        Offset offset = new Offset(0);
+        int offsetAnterior;
+        int bytesLidos;
+
+        do {
+            offsetAnterior = offset.getValue();
+            fileSystem.read(caminho, user, buffer, offset);
+            bytesLidos = offset.getValue() - offsetAnterior;
+
+            if (bytesLidos > 0) System.out.write(buffer, 0, bytesLidos);
+        } while (bytesLidos > 0);
+
+        System.out.flush();
+        System.out.println();
     }
 
     public static void mv() throws CaminhoNaoEncontradoException, PermissaoException {
         System.out.println("Insira o caminho do arquivo a ser movido:");
         String caminhoAntigo = scanner.nextLine();
         System.out.println("Insira o novo caminho do arquivo:");
         String caminhoNovo = scanner.nextLine();
-        
+
         fileSystem.mv(caminhoAntigo, caminhoNovo, user);
     }
 
@@ -232,7 +238,7 @@ public static void ls() throws CaminhoNaoEncontradoException, PermissaoException
         String caminho = scanner.nextLine();
         System.out.println("Listar recursivamente? (true/false):");
         boolean recursivo = Boolean.parseBoolean(scanner.nextLine());
-        
+
         fileSystem.ls(caminho, user, recursivo);
     }
 
@@ -243,7 +249,7 @@ public static void cp() throws CaminhoNaoEncontradoException, PermissaoException
         String caminhoDestino = scanner.nextLine();
         System.out.println("Copiar recursivamente? (true/false):");
         boolean recursivo = Boolean.parseBoolean(scanner.nextLine());
-        
+
         fileSystem.cp(caminhoOrigem, caminhoDestino, user, recursivo);
     }
 }

exception/OperacaoInvalidaException.java

@@ -0,0 +1,7 @@
+package exception;
+
+public class OperacaoInvalidaException extends Exception {
+    public OperacaoInvalidaException(String message) {
+        super(message);
+    }
+}

filesys/Arquivo.java

@@ -0,0 +1,73 @@
+package filesys;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Arquivo extends ElementoFS {
+    private List<byte[]> blocos;
+    private long tamanho;
+
+    public Arquivo(String nome, String permissoes, String dono) {
+        super(nome, permissoes, dono);
+        // this.arquivo = new Bloco[0];
+        this.blocos = new ArrayList<>();
+        this.tamanho = 0;
+    }
+
+    /*
+     * public Bloco[] getArquivo() {
+     * return arquivo;
+     * }
+     * 
+     * public void setArquivo(Bloco[] arquivo) {
+     * this.arquivo = arquivo;
+     * }
+     */
+
+    public void adicionarBloco(byte[] dados) {
+        blocos.add(dados);
+        tamanho += dados.length;
+    }
+
+    public List<byte[]> getBlocos() {
+        return blocos;
+    }
+
+    public long getTamanho() {
+        return tamanho;
+    }
+
+    public void removerBloco(int index) {
+        if (index < 0 || index >= blocos.size()) {
+            throw new IndexOutOfBoundsException("Índice fora dos limites da lista.");
+        }
+        byte[] removed = blocos.remove(index);
+        tamanho -= removed.length;
+    }
+
+    public void limparBlocos() {
+        blocos.clear();
+        tamanho = 0;
+    }
+
+    @Override
+    public boolean isArquivo() {
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return "Arquivo: " + nomeDiretorio + " | Dono: " + donoDiretorio + " | Permissões: " + permissoesPadrao + " | Tam: "
+                + tamanho + " bytes";
+    }
+
+    public void adicionarFilho(ElementoFS filho) {
+        throw new UnsupportedOperationException("Não é possível adicionar filhos a um arquivo.");
+    }
+
+
+    public void removerFilho(String nomeFilho) {
+        throw new UnsupportedOperationException("Não é possível remover filhos de um arquivo.");
+    }
+
+}

filesys/Bloco.java

@@ -0,0 +1,19 @@
+package filesys;
+
+public class Bloco {
+    private static final int TAMANHO_BLOCO = 4096; // 4KB por bloco
+    private byte[] dados;
+
+
+    public Bloco(int tamanho) {
+        this.dados = new byte[TAMANHO_BLOCO];
+    }
+
+    public byte[] getDados() {
+        return dados;
+    }
+
+    public void setDados(byte[] dados) {
+        this.dados = dados;
+    }
+}