Segunda Parte: Servidor Java que bloquea y modifica archivos solicita cliente

[Lorenzo31]

Buenas noches, dejo la segunda parte del ejercicio, solo falta la parte visual del cliente y un par de modificaciones.

Comentario: Tomé nota del comentario de César sobre la recursividad sin fin, y lo he arreglado para mayor eficiencia.

Para ver el texto del ejercicio visitar el otro hilo,

https://www.aprenderaprogramar.com/foros/index.php?topic=3209.0 

Comandos aceptados

get "archivo.txt"   devuelve archivo a c:/Mantequilla.txt
lock "archivo.txt"   bloquea archivo solicitado
        get                 envia archivo bloqueado a c:/Mantequilla.txt
        put                  retorna con las modificaciones el archivo al original
unlock "archivo.txt"   desbloquea el archivo
bye                            cierra cliente


También permite la conexion de multiusuarios.

En la ultima modificacion perfilaré el entorno visual y permitiré seleccionar el path de envio aunque no lo solicite el ejercicio, me parece más funcional.
Tambien cambiaré los Buffered para que puedan enviarse otro tipo de archivos mayores. (Espero poder lograr esta parte)

Como siempre espero críticas y comentarios constructivos que tanto me ayudan.

[César Krall]

Hola Lorenzo!

Al igual que hice en el otro hilo repito lo mismo, se trata de una aportación valiosa porque se practica con muchos conceptos interesantes. Con tu permiso voy a trasladar el código que has creado para que esté visible dentro del hilo del foro y las personas que lo vean puedan hacerse una idea sobre el código sin tener que descargar el fichero como adjunto.


Clase ServidorDeFicheros

Código: [Seleccionar]

import java.io.*;
import java.net.*;

public class ServidorDeFicheros
{

    public static final int PORT = 4444;
    public static void main (String args[]) {
        int identificador = 1;
        ServerSocket servidor = null;
        Socket cliente = null;

        try{ servidor = new ServerSocket(PORT);
        }catch(IOException e){System.out.println("Error al conectar con el servidor"); System.exit(-1);}

        /* Se bloquea mientras escucha */
        System.out.println("Servidor escuchando: " + servidor + " " + servidor.getInetAddress());

        while(true){
            try { cliente = servidor.accept(); } catch (IOException e){ System.out.println("Error al conectar con cliente " + identificador); }
            new HiloPeticionCliente(cliente, identificador).start();
            identificador++;
        }

    }
}


Clase HiloPeticionCliente

Código: [Seleccionar]

import java.io.*;
import java.net.*;
import java.nio.channels.FileChannel; import java.nio.channels.FileLock; import java.nio.channels.OverlappingFileLockException; import java.nio.file.Files;
import java.nio.file.Path; import java.nio.file.Paths; import java.nio.file.StandardOpenOption;

public class HiloPeticionCliente extends Thread {
    Socket cliente;
    int identificador;
    BufferedReader entrada = null;
    //PrintWriter salida = null;
    OutputStream sendChannel = null;
    String cadena = ""; String comando = ""; String orden = "";  //Strings para recibir y gestionar la orden del usuario.
    boolean primerEspacio = false;
    //Variables para la gestión del bloqueo de archivo seleccionado
    boolean bloqueado = false;
    FileChannel channel; FileLock lock; File archivoBloqueado;
    RandomAccessFile accesoABloqueo;

    public HiloPeticionCliente (Socket cliente, int identificador){
        this.cliente = cliente; this.identificador = identificador; }

    public void run(){

        while(!cliente.isClosed()){
            leerOrdenCliente();

            System.out.println("Buscando archivo solicitado en comando: " + cadena);

            procesarOrdenCliente();

            switch(orden){  //coge la orden y la compara con las aceptadas por la máquina, el resto indica que no son correctas en el default mandando -1
                case "bye": System.out.println("Finalizada la conexion con el cliente " + identificador);
                try{ cliente.close();} catch(IOException e){}; interrupt(); break;

                case "get": getArchivo(); break;

                case "lock": lockArchivo(); break;

                case "put": putArchivoModificado(); break;

                case "unlock":  unlockArchivo(); break;

                default: try { sendChannel.write(-1); } catch (Exception e){}  comando = ""; orden = "";
            }

        }
    }

    /*lee la entrada del Cliente y devuelve String */
    private String leerOrdenCliente() {  try{   
            //Establece canal de entrada
            entrada = new BufferedReader (new InputStreamReader(cliente.getInputStream()));
            //Establece canal envio archivos
            sendChannel = cliente.getOutputStream();
            //lectura entrada usuario
            cadena = entrada.readLine();

        } catch(IOException e ) { System.out.println(e.getMessage()); }
        return cadena;
    }

    /*Traduce la entrada del cliente dividiendo la orden del fichero a tratar*/
    private void procesarOrdenCliente() { //comprueba si el comando introducido es mayor a 3 letras (get, put, bye) y si es así guarda hasta el primer espacio

        if(cadena.length() > 3){
            for (int x = 0; x < cadena.length(); x++){
                //guarda la orden hasta el espacio, get lock o unlock en el String orden
                if(cadena.substring(x, x+1).equals(" ") && !primerEspacio){ orden = cadena.substring(0, x); primerEspacio = true; }
                // elimina espacios y comillas de la orden recibida y los guarda en comando
                if(!cadena.substring(x, x+1).equals(" ") && !cadena.substring(x, x+1).equals("\"")){ comando = comando + cadena.substring(x, x+1); }//final for
            }
            primerEspacio = false; //al salir del bucle for , iniciamos el boolean primer espacio a false para la proxima entrada.
        } else orden = cadena;  }

    /*Busca el archivo de la orden get */
    private void getArchivo(){ //crea instancia de clase buscar archivo y invoca a la funcion buscador para encontrar el archivo solicitado

        if(!bloqueado){   //si no está bloqueado significa que es un get archivo normal
            if(comando.length() > 3){ //comando debe contener get y además el archivo a buscar, más de 3 caracteres.
                File archivoEncontrado = buscarArchivo();
                if(archivoEncontrado != null){
                    new HiloEnvio (cliente, archivoEncontrado).start();  } else { try { sendChannel.write(-1); } catch (Exception e){} }
                comando = ""; orden = ""; } else try { sendChannel.write(-1); } catch (Exception e){}

        }else {
            try{
                Path archivoModificado = Paths.get("C:/Mantequilla.txt");
                try{
                    desbloquearCanal(); //desbloqueo del archivo bloqueado

                    byte[] contenedor = Files.readAllBytes(archivoBloqueado.toPath());
                    Files.write(archivoModificado, contenedor, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING); 

                    try{ sleep(1000); }catch (InterruptedException e) { e.printStackTrace(); }
                    lock = channel.lock();
                }catch (IOException e){  }

            }catch(Exception e){};
            cambioRealizado();  }
    }           

    /*Put sobreescribir archivo con archivo modificado*/
    private void putArchivoModificado(){
        if (bloqueado){
            Path archivoModificado = Paths.get("C:/Mantequilla.txt");

            try{
                desbloquearCanal(); //desbloqueo del archivo bloqueado

                byte[] arrayBytes = Files.readAllBytes(archivoModificado); //pasamos el contenido del archivo modificado a un array de bytes
                // Escritura en el archivoBloqueado
                Files.write(archivoBloqueado.toPath(), arrayBytes, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING); 
                try{ sleep(1000); }catch (InterruptedException e) { e.printStackTrace(); }

                lock = channel.lock();
            }catch (IOException e){  }

            cambioRealizado();

        } else { try { sendChannel.write(-1); } catch (Exception e){}  }
    }

    /*Desbloquear archivo */
    private void unlockArchivo(){ if(bloqueado){try {
                try {  lock = channel.tryLock(); }catch (IOException ioe){}
            } catch (OverlappingFileLockException e) {  try { lock.release();   channel.close(); }catch (IOException ioe2){} }
            archivoBloqueado = null; bloqueado = false; System.out.println("Archivo desbloquado");
            cambioRealizado();
        }else try { sendChannel.write(-1); } catch (Exception e){}
    }

    /*Busqueda y bloqueo de archivo con comando LOCK*/
    private void lockArchivo(){
        if(!bloqueado){ BuscadorArchivo find = new BuscadorArchivo();
            archivoBloqueado = find.buscador(comando.substring(orden.length(), comando.length() ), new File("C:\\"));
            if(archivoBloqueado != null) {
                try{   
                    accesoABloqueo = new RandomAccessFile(archivoBloqueado, "rws"); //aqui podemos acceder al archivo para leer y escribir en el
                    channel = accesoABloqueo.getChannel();
                    lock = channel.lock(); }catch (IOException e){}
                bloqueado = true; System.out.println("Archivo bloqueado."); cambioRealizado();  }
            else{ try { sendChannel.write(-1); } catch (Exception e){} }
        }
    }

    private File buscarArchivo(){
        BuscadorArchivo find = new BuscadorArchivo();
        return find.buscador(comando.substring(orden.length(), comando.length() ), new File("C:\\"));  }

    /*Orden Realizada correctamente*/
    private void cambioRealizado(){
        comando = ""; orden = "";
        String textoEnvio = "Done.";
        byte[] arrayBytes = textoEnvio.getBytes();
        try{ sendChannel.write(arrayBytes);  } catch (IOException e) { System.out.println(e); }
    }

    void desbloquearCanal(){ try{ lock.release(); }catch(IOException e ){} }
}

Clase HiloEnvio

Código: [Seleccionar]

import java.net.*;
import java.io.*;
/**
 * Clase HiloEnvio extiende de Thread y es la encargada de recibir el archivo encontrado y el canal con el cliente, que utiliza para enviar el archivo a destino
 *
 * @author Lorenzo31
 * @version (a version number or a date)
 */
public class HiloEnvio extends Thread
{
    private File archivo;
    private Socket socketCliente = null;
    private FileInputStream fileChannel = null;
    private BufferedInputStream lectorArchivo = null;
    private BufferedOutputStream sendChannel = null;

    public HiloEnvio(Socket socketCliente, File archivo){ this.socketCliente = socketCliente; this.archivo = archivo;}
    public void run() {
        // send file
        try{

            byte [] mybytearray = new byte [(int)archivo.length()];

            fileChannel = new FileInputStream(archivo);
            lectorArchivo = new BufferedInputStream(fileChannel);
            lectorArchivo.read(mybytearray,0,mybytearray.length);
            sendChannel = new BufferedOutputStream(socketCliente.getOutputStream());
            System.out.println("Sending " + archivo + "(" + mybytearray.length + " bytes)");
            //envio archivo
            sendChannel.write(mybytearray,0,mybytearray.length);
            sendChannel.flush();

            System.out.println("Done.");
        }catch (IOException | NullPointerException e) { System.out.println("Interrumpido. ");
            interrupt();
        }
    }
}

Clase BuscadorArchivo

Código: [Seleccionar]

import java.io.*;
import java.net.*;

public class BuscadorArchivo {
    File archivoEncontrado = null;
    boolean encontrado;

    public BuscadorArchivo()  { this.encontrado = false; /*siempre que se llama al buscador reinicia a false el boolean */ }

    public File buscador(String nombre, File raiz){
        if(!encontrado){ //si no esta encontrado entra en el for para buscar
            File[] lista = raiz.listFiles();

            if(lista != null) {
                for(File elemento : lista) {
                    if (elemento.isDirectory())  {
                        buscador(nombre, elemento);
                    } else if (nombre.equalsIgnoreCase(elemento.getName()))
                    {
                        archivoEncontrado = elemento;
                        encontrado = true;   
                    }
                }
            }
        } else { return archivoEncontrado; }   

        return archivoEncontrado;
    } //cierre buscador
}


Clase ClienteFicheros

Código: [Seleccionar]

import java.io.*;
import java.net.*;
import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths;
import java.nio.channels.FileChannel;

public class ClienteFicheros
{
    public static void main(String[] args) throws IOException {

        int bytesRead;

        BufferedOutputStream bos = null;
        Socket socketCliente = null;

        PrintWriter salida = null;

        String hostName = InetAddress.getLocalHost().getHostName();
        /* Creamos un socket en el lado cliente, enlazado con un servidor que está en la misma máquina
        que el cliente y que escucha en el puerto 4444 */

        try{ socketCliente = new Socket(hostName, 4444);
            System.out.println("servidor conectado:" + hostName);

            //Obtenemos el canal de salida
            salida = new PrintWriter( new BufferedWriter( new OutputStreamWriter(socketCliente.getOutputStream())),true);
        }catch(IOException e){
            System.err.println("No puede establecer conexion");
            System.exit(-1); }

        BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));

        String linea = "";

        /*El programa cliente no analiza los mensajes enviados por el usuario, simplemente los
         * reenvia al servidor hasta que este se despide con Adios*/
        while(!linea.equalsIgnoreCase("bye")){   

            do{
                System.out.println("Introduce comando válido:");
                //Leo la entrada del usuario
                linea = stdIn.readLine();

                //parámetros permitidos en la introducción de datos del usuario: lock unlock get put get "archivo"
            }while (!linea.matches("[a-z][a-z][a-z] \".*\"") && !linea.matches("[a-z][a-z][a-z]") && !linea.matches("[l][o][c][k] \".*\"")
            && !linea.matches("[u][n][l][o][c][k] \".*\""));
            //La envia al servidor
            salida.println(linea);

            if(!linea.equalsIgnoreCase("bye")){
                OutputStream fos = null;
                try {
                    //reciibr archivo
                    //Creamos array de bytes

                    byte [] mybytearray  = new byte [1000000];
                    //Creamos objeto InputStream que abre la cadena de entrada para lectura del fichero que mande servidor
                    BufferedInputStream cadenaReceptor = new BufferedInputStream (socketCliente.getInputStream());
                    bytesRead = cadenaReceptor.read(mybytearray,0,mybytearray.length);
                    //}
                    //Si al ejecutar la orden el servidor no reenvia ningun fichero ni un texto vacio, por error de sintaxis ,
                    //manda un "Done." y el valor de bytesRead es 0 para identificarlo
                    //BufferedReader comprobar = new BufferedReader( new InputStreamReader(cadenaReceptor));

                    switch(bytesRead){
                        case 1:   //1 valor que toma como mínimo un archivo Outputstream, significa archivo no encontrado o no buscado

                        System.out.println("Archivo no encontrado o comando erroneo"); break;

                        case -1: //-1 valor que toma al no recibir ningun archivo erroneo ni correcto, solo con BYE

                        System.out.println("Sesion finalizada"); break;

                        case 5:  //0 indica orden realizada correctamente

                        System.out.println("Done."); break;

                        default:
                        Path direccionDestino = (Paths.get("C:/Mantequilla.txt")).toAbsolutePath();

                        File file = new File(direccionDestino.toString());
                        fos = new FileOutputStream(file); 

                       
                        bos = new BufferedOutputStream(fos);
                        bos.write(mybytearray, 0 , bytesRead);
                        bos.flush();
                        fos.close();
                        System.out.println("File downloaded (" + bytesRead + " bytes read) at " + direccionDestino.toString() ); 

                    } //end switch
                }catch(IOException e){ System.out.println("Error en la transmisión.");
                    if (fos != null) fos.close();
                    if (bos != null) bos.close();
                    if (socketCliente != null) socketCliente.close(); }
            }
        }
        System.out.println("Sesión finalizada.");

        // if (fos != null) fos.close();
        if (bos != null) bos.close();
        if (socketCliente != null) socketCliente.close();

    }
}


[César Krall]

Hola Lorenzo he intentado hacer la misma prueba que la otra vez pero me ha saltado un error, igual es que no he hecho lo que tenía que hacer. Te indico lo que he hecho:

Para hacer una prueba, he creado un fichero denominado prueba.txt y lo he ubicado en el escritorio.

Para comenzar, he ejecutado el método main de la clase ServidorDeFicheros.

Por pantalla ha salido:

Servidor escuchando: ServerSocket[addr=0.0.0.0/0.0.0.0,localport=4444] 0.0.0.0/0.0.0.0

He abierto otro entorno de ejecución Java y ejecutado el método main de la clase ClienteFicheros

Por pantalla me ha salido:

servidor conectado:Krall
Introduce comando válido:

He escrito get "prueba.txt"

En el terminal me ha salido Error en la transmisión.


En el otro terminal me ha salido

Servidor escuchando: ServerSocket[addr=0.0.0.0/0.0.0.0,localport=4444] 0.0.0.0/0.0.0.0
Buscando archivo solicitado en comando: get "prueba.txt"
Sending C:\Users\Krall\Desktop\prueba.txt(194 bytes)
Done.
Buscando archivo solicitado en comando: null

Y en la parte inferior:

Exception in thread "Thread-1" java.lang.NullPointerException
   at HiloPeticionCliente.procesarOrdenCliente(HiloPeticionCliente.java:65)
   at HiloPeticionCliente.run(HiloPeticionCliente.java:29)


El programa se ha quedado bloqueado y he tenido que detenerlo manualmente

No estoy seguro si he hecho algo mal o puede estar relacionado con permisos para escribir en C:, es decir, C: es un directorio que en muchos ordenadores tiene restricción de acceso porque en él hay contenido sensible y no se permite escribir directamente en este directorio

Saludos!

[Lorenzo31]

Hola muy buenas César, exacto te salta el null por restricción de permisos del directorio. A mi me pasó lo mismo y modifiqué eso.

Prueba a cambiar el path a ver si así, poniendo otra direccion, pero en principio funciona perfecto el envio del get.

Y claro no me importa que cuelgues el código lo hago para aportar cosas al resto que puedan servirles

Ya me dirás si te funcionó con otra dirección.

[César Krall]

Ahora sí, cambiando la ruta ha funcionado.

Al igual que hice en el otro hilo, pongo la explicación de pasos a seguir para quien quiera probar el programa. El programa simula el envío o descarga de un fichero desde un servidor hasta un cliente. En este caso tanto el servidor como el cliente va a ser nuestro equipo, pero normalmente serían equipos remotos.

En la clase ClienteFicheros aparece la siguiente línea:

Path direccionDestino = (Paths.get("C:/Mantequilla.txt")).toAbsolutePath();

Es recomendable cambiar esta línea para que la ruta no sea directa a C:, por ejemplo dejarla así:

Path direccionDestino = (Paths.get("C:/Users/Krall/Desktop/pruebas/Mantequilla.txt")).toAbsolutePath();

Aquí tenemos que la ruta donde se va a descargar el fichero y el nombre que va a tener el fichero descargado (Mantequilla.txt), si queremos podemos cambiar la ruta y/o el nombre.

Para hacer una prueba, crear un fichero por ejemplo denominado prueba.txt y ubicarlo en el escritorio (o en otro lugar).

Para comenzar, ejecutar el método main de la clase ServidorDeFicheros. Es posible que salte una alerta de Firewall de Windows. En este caso elegir "Permitir acceso"

Por pantalla nos saldrá (ventana ServidorDeFicheros):

Servidor escuchando: ServerSocket[addr=0.0.0.0/0.0.0.0,localport=4444] 0.0.0.0/0.0.0.0

Abrir otro entorno de ejecución Java y ejecutar el método main de la clase ClienteFicheros

Por pantalla nos saldrá:

servidor conectado:NombreServer
Introduce comando válido:

Escribimos get "prueba.txt"

Con esto lo que hemos dicho es "busca el archivo prueba.txt dentro del servidor y descárgalo al cliente en la ruta C:/Users/Krall/Desktop/pruebas/Mantequilla.txt" (o aquella ruta que hayamos indicado).

En ese momento comienza la búsqueda del fichero prueba.txt dentro del servidor (esto puede tardar un par de minutos). No te desesperes, esto tarda un poco porque tiene que ir buscando en todas las carpetas del computador hasta encontrar el archivo.

En la ventana de ClienteFicheros obtendremos al cabo de un par de minutos:

servidor conectado:Krall
Introduce comando válido:
get "prueba.txt"
File downloaded (110 bytes read) at C:\Users\Krall\Desktop\pruebas\Mantequilla.txt
Introduce comando válido:


Aquí como comando introduciremos bye para desconectar y nos aparecerá "Sesión finalizada"

En la ventana de ServidorFicheros nos habrá quedado lo siguiente:

Servidor escuchando: ServerSocket[addr=0.0.0.0/0.0.0.0,localport=4444] 0.0.0.0/0.0.0.0
Buscando archivo solicitado en comando: get "prueba.txt"
Sending C:\Users\Mario R. Rancel\Desktop\prueba.txt(110 bytes)
Done.


Después de pulsar bye ya nos aparece:

Servidor escuchando: ServerSocket[addr=0.0.0.0/0.0.0.0,localport=4444] 0.0.0.0/0.0.0.0
Buscando archivo solicitado en comando: get "prueba.txt"
Sending C:\Users\Mario R. Rancel\Desktop\prueba.txt(110 bytes)
Done.
Buscando archivo solicitado en comando: bye
Finalizada la conexion con el cliente 1


Ahora en la ruta indicada podremos comprobar que se encuentra el fichero Mantequilla.txt (que es el fichero prueba.txt que se ha descargado al cliente con el nombre Mantequilla.txt).

Lorenzo, ¿puedes explicar para qué sirven las otras opciones?

lock "archivo.txt"   bloquea archivo solicitado
        get                 envia archivo bloqueado a c:/Mantequilla.txt
        put                  retorna con las modificaciones el archivo al original
unlock "archivo.txt"   desbloquea el archivo

Saludos!

[Lorenzo31]

Sí como no. La C: la mas problemas si para usarla lo tendré en cuenta en el futuro.

Las nuevas opciones son todas para una misma función, se trata de pretender modificar un fichero del servidor, desde tu equipo, cogiendolo previamente.

Para ello se necesita primero bloquear el fichero que vas a usar del servidor
lock "prueba.txt"
este comando impedirá que nadie modifique el fichero, al ir manualmente a modificarlo windows no lo permitirá.
get
después de un lock , el servidor permite un get sin nombre de archivo, porque sabe que nos referimos al archivo bloqueado solicitado previamente.
Con este comando, nos lo envia al destino marcado, el fichero prueba.txt seguirá bloqueado.
put
Una vez recibido el fichero, podemos modificarlo en el cliente , la ruta creo es Mantequilla.txt igual, y al poner put en el comando, leerá el archivo modificado y lo trasladara a prueba.txt. El fichero prueba.txt seguirá bloqueado
unlock "prueba.txt"
Con este comando finaliza el proceso y libera el bloqueo de escritura en el archivo original solicitado, y ya lo ha modificado.

Como apunte, logré mejorar la eficiencia del buscador con un boolean global de clase, que al modificarlo por encontrar el fichero, no permita buscar más a las nuevas funciones que se crean, ahorrando mucho tiempo como me indicaste en el otro post.

[manuromero73]

¿se puede crear la comunicacion entre dos computadores distintos o tiene que ser siempre en el mismo? Gracias

[Lorenzo31]

Se puede entre dos ordenadores diferentes, tan solo hay que modificar la InetAddress a la  que se conecta el cliente. Averigua la ip del servidor y haz que conecte el cliente ahí.

En la ultima entrega, no solo haré que puedan descargarse cualquier archivo sino que tambien se pueda conectar remotamente desde multiples Pc's.
 Si los administradores lo consideran lo subiré aquí para que sirva a otros de forma didactica.

Lo de los archivos grandes ya  lo he logrado, y la conexion remota es simplemente un par de comandos de InetAddress, si lo buscas tu mismo puedes modificar esa parte Manu.

[Lorenzo31]

Dejo escrito algo importante sobre el proyecto. Desde ayer la linea

Código: [Seleccionar]

  Files.write(archivoModificado, contenedor, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING); 
De la clase  HiloPeticionCliente  concretamente de la funcion get archivo, no funciona en ninguno de mis pc's.
La he sustituido por

Código: [Seleccionar]

Files.write(archivoModificado, contenedor);Que básicamente tiene como opciones sin que se le indique por defecto CREATE, WRITE y TRUNCATE, es decir las  mismas que yo solicitaba pero con create , han debido modificar algo, dejo esto dicho para futuras personas que lo puedan necesitar.

[César Krall]

Hola lorenzo ¿a qué o quién te refieres con han debido modificar algo? ¿A un cambio en la especificación de la versión de java debido a una nueva versión?

[Lorenzo31]

Hola César, si, me refiero exactamente a que la clase Files ha podido ser modificada por algun tipo de nueva versión, porque el Files.write que yo tenia iba correctamente hasta hace dos dias (y yo no habia modificado nada).

Primero pensé que pudiera ser algo de permisos del PC pero al ocurrirme lo mismo otro PC con la version primera del programa. Obviamente el problema venía de algo fuera de mi mano. 

Quizás al no estipular CREATE como StandardOpenOption, ya no lo hace automaticamente, si especificas otras StandardOpenOption, no lo sé. Pero revisé la documentacion y vi que por defecto, si no escribias ninguna Option, la orden ejecuta CREATE, WRITE, y TRUNCATE (justo lo que necesitaba que hiciera) y lo modifiqué y funcionaba de nuevo.