gplib/include/gp/ipc/io/io_operation.hpp

#pragma once

#include "gp/containers/array.hpp"

#include <cstddef>
#include <cstdint>

// TODO: File locking and fsync/fdatasync
namespace gp {
	/**
	* @brief this enum represents the types of operations available
	*/
	enum class operation_type {
		version, ///< this operation queries properties of the filesystem
		flush, ///< flushes any buffer for writing on the filesystem
		attach, ///< adds a filesystem to the system
		detach, ///< remove a filesystem from the system
		walk, ///< change the current directory
		create, ///< creates a file
		open, ///< opens a file, yielding a fid
		read, ///< reads from a file
		write, ///< writes to a file
		clunk, ///< relinquishes a fid
		remove, ///< removes a file
		stat, ///< reads a file metadata
		wstat ///< writes a file metadata
	};

	/**
	* @brief this enum represent the type of file handled
	*/
	enum class file_type {
		directory, ///< the file is a normal directory
		master_directory, ///< the file is the root directory of a non-root filesystem
		device_directory, ///< the file is a driver mapped to a directory
		root_directory, ///< the file is the root directory
		file, ///< the file is a normal file
		file_device, ///< the file is a driver mapped to a file
		message_pipe ///< the file is a channel to read and write messages to
	};

	/**
	* @brief represents file permissions
	*/
	struct permission_list {
		bool 
		read : 1,
		write : 1,
		execute : 1;
	};

	/**
	* @brief represents all levels of permissions in a file
	*/
	struct file_permissions {
		permission_list
			user, ///< list of permissions for the owner
			group, ///< list of permissions for the owning group
			others; ///< list of permissions for other users
	};

	/**
	* @brief represent a value that should be unique for every entity of the system
	*/
	using unique_node = uint64_t;

	/**
	* @brief represent a timestamp in seconds
	*/
	using timestamp = uint64_t;

	/**
	* @brief represent a value that represent an offset into a file
	*/
	using file_offset = uint64_t;

	/**
	* @brief the expected return type of a stat query, as well as its writing counterpart
	*/
	struct f_stats {
		file_type type; ///< the type of file
		unique_node file_id; ///< the unique file id
		unique_node owner_user_id; ///< the user id of the owner of the file
		unique_node owner_group_id; ///< the group id of the file
		unique_node last_modifier_id; ///< the user id of the last user that wrote data to the file
		timestamp last_access; ///< the timestamp for the last time the file was opened or created. If the current user is not root, it is replaced by the system on wstat
		timestamp last_modification; ///< the last modification timestamp. If the current user is not root, it is replaced by the system on wstat
		file_offset file_size; ///< the filesize in bytes
		gp::array<char, 255> filename; ///< the filename, padded with null characters
	};

	/**
	* @brief Represent an IO operation as sent to the system, this is an abstract class.
	*/
	struct io_operation {
		const operation_type type; ///< the discriminant for the operation type
	protected:
		io_operation(operation_type a) : type(a) {}
	};

	/**
	* @brief This operation obtains the version of the targeted filesystem
	*/
	struct version_operation : public io_operation {
		const gp::buffer<char> destination; ///< the destination where the data is written
		const gp::buffer<char> root_path; ///< the path of the file system to query for version
		const gp::optional<gp_config::file_descriptor_t> fd; ///< the relative root to use

		/**
		* @brief Construct a new version operation object
		* 
		* @param dest the destination where the data is written
		* @param path the path to the target filesystem
		* @param v_fd a relative root that is used
		*/
		version_operation(
			gp::buffer<char> dest, 
			gp::buffer<char> path, 
			gp::optional<gp_config::file_descriptor_t> v_fd
		)
		: io_operation{operation_type::version}
		, destination(dest)
		, root_path(path)
		, fd(v_fd)
		{}
	};

	/**
	* @brief This operation flushes a filesystem, writing the data to the associated medium
	*/
	struct flush_operation : public io_operation {
		const gp::buffer<char> root_path; ///< the path that is going to be flushed
		const gp::optional<gp_config::file_descriptor_t> fd; ///< the relative root to use

		/**
		* @brief Construct a new flush operation object
		* 
		* @param path the path to a file or to a master directory that is to be flushed
		* @param v_fd a relative root that is used
		*/
		flush_operation(
			gp::buffer<char> path, 
			gp::optional<gp_config::file_descriptor_t> v_fd
		)
		: io_operation{operation_type::flush}
		, root_path(path)
		, fd(v_fd)
		{}
	};

	/**
	* @brief This operation mounts a filesystem given a format and a configuration data.
	*
	* It also mounts devices.
	*/
	struct attach_operation : public io_operation {
		const gp::buffer<char> target_path; ///< location where the filesystem is going to be attached
		const gp::buffer<char> format; ///< format string of the filesystem
		const gp::buffer<char> configuration; ///< configuration data
		const gp::optional<gp_config::file_descriptor_t> fd; ///< the relative root to use

		/**
		* @brief Construct a new attach operation object
		* 
		* @param path path where the filesystem will be attached, must be either not existing or an empty directory
		* @param v_format the format name that will be invoked with the config
		* @param config the configuration to send
		* @param v_fd a relative root that is used
		*/
		attach_operation(
			gp::buffer<char> path, 
			gp::buffer<char> v_format, 
			gp::buffer<char> config, 
			gp::optional<gp_config::file_descriptor_t> v_fd
		)
		: io_operation{operation_type::attach}
		, target_path(path)
		, format(v_format)
		, configuration(config)
		, fd(v_fd)
		{}
	};

	/**
	* @brief This operation removes the master status of a directory and dismounts the 
	* filesystem attached to it after flushing it. Will fail if any file is still attached 
	* in the filesystem.
	*
	* This applies to the devices too.
	*/
	struct detach_operation : public io_operation {
		const gp::buffer<char> target_path; ///< the target master directory
		const gp::optional<gp_config::file_descriptor_t> fd; ///< the relative root to use

		/**
		* @brief Construct a new detach operation object
		* 
		* @param path the item to be detached
		* @param v_fd a relative root that is used
		*/
		detach_operation(
			gp::buffer<char> path, 
			gp::optional<gp_config::file_descriptor_t> v_fd
		)
		: io_operation{operation_type::attach}
		, target_path(path)
		, fd(v_fd)
		{}
	};

	/**
	* @brief This operation will move the focus of the target directory relative to itself or absolutely
	*/
	struct walk_operation : public io_operation {
		const gp::buffer<char> target_path; ///< the target to move to
		const gp_config::file_descriptor_t fd_to_alter; ///< the fd that will be modified

		/**
		* @brief Construct a new walk operation object
		* 
		* @param path the target to move to
		* @param dir the original file descriptor
		*/
		walk_operation(
			gp::buffer<char> path, 
			gp_config::file_descriptor_t dir
		)
		: io_operation{operation_type::walk}
		, target_path(path)
		, fd_to_alter(dir)
		{}
	};

	/**
	* @brief selector for the type of file to be created in a given environment
	*/
	enum class create_type {
		file, ///< normal file
		directory, ///< directory file
		temporary, ///< file which is to be remove upon all of his descriptors being closed
		pipe_read_side, ///< pipe, read side returned
		pipe_write_side ///< pipe, write side returned
	};

	/**
	* @brief This operation will attempt to create a file at the specified destination
	*/
	struct create_operation : public io_operation {
		const gp::buffer<char> target_path;
		const create_type mode;
		const gp::optional<gp_config::file_descriptor_t> fd;

		/**
		* @brief Create a new create operation object
		* 
		* @param path the new file that is created
		* @param v_mode the type of file to create
		* @param v_fd a relative root that is used
		*/
		create_operation(
			gp::buffer<char> path, 
			create_type v_mode,
			gp::optional<gp_config::file_descriptor_t> v_fd
		)
		: io_operation{operation_type::create}
		, target_path(path)
		, mode(v_mode)
		, fd(v_fd)
		{}
	};

	/**
	* @brief selector for the properties expected from an opened file descriptor
	*/
	enum class open_mode {
		read_only, ///< the descriptor will be read only, will fail if no read permissions
		read_write, ///< the descriptor is read-write, will fail if no write permissions, but not if no read permissions
		read_write_create ///< the descriptor is read-write, and has the same proterties as the read-write. The file will be created if it does not exist.
	};

	/**
	* @brief This operation will attempt to open a file at the specified destination
	*/
	struct open_operation : public io_operation {
		const gp::buffer<char> target_path; ///< the specified path
		open_mode mode; ///< the openning mode
		const gp::optional<gp_config::file_descriptor_t> fd; ///< the relative root to use

		/**
		* @brief Construct a new open operation object
		* 
		* @param path the path where to open a file
		* @param v_mode the mode of opening
		* @param v_fd a relative root that is used
		*/
		open_operation(
			gp::buffer<char> path, 
			open_mode v_mode, 
			gp::optional<gp_config::file_descriptor_t> v_fd
		)
		: io_operation{operation_type::create}
		, target_path(path)
		, mode(v_mode)
		, fd(v_fd)
		{}
	};

	/**
	* @brief This operation will attempt to read a file into the destination starting at the specified offset in the file
	*/
	struct read_operation : public io_operation {
		const gp_config::file_descriptor_t fd; ///< the file to read
		const file_offset offset; ///< the offset to start reading at
		const gp::buffer<char> destination; ///< the destination where to write the data

		/**
		* @brief Construct a new read operation object
		* 
		* @param v_fd the descriptor to read
		* @param off the offset to read
		* @param v_destination the location where the data will be written
		*/
		read_operation(
			gp_config::file_descriptor_t v_fd, 
			file_offset off, 
			gp::buffer<char> v_destination
		)
		: io_operation{operation_type::read}
		, fd{v_fd}
		, offset(off)
		, destination(v_destination)
		{}
	};

	/**
	* @brief This operation will attempt to write in file from the source starting at the specified offset in the file
	*/
	struct write_operation : public io_operation {
		const gp_config::file_descriptor_t fd; ///< the descriptor of the file where writing happens
		const file_offset offset; ///< the offset in the file where writing starts
		const gp::buffer<char> source; ///< the source data

		/**
		* @brief Construct a new write operation object
		* 
		* @param v_fd the target file
		* @param off the target offset
		* @param v_source the data source buffer
		*/
		write_operation(
			gp_config::file_descriptor_t v_fd, 
			file_offset off, 
			gp::buffer<char> v_source
		)
		: io_operation{operation_type::write}
		, fd{v_fd}
		, offset(off)
		, source(v_source)
		{}
	};

	/**
	* @brief This operation closes a file by relinquishing its file descriptor
	*/
	struct clunk_operation : public io_operation {
		const gp_config::file_descriptor_t fd; ///< The descriptor that will be disposed of

		/**
		* @brief Construct a new clunk operation object
		* 
		* @param v_fd the fd to close
		*/
		clunk_operation(gp_config::file_descriptor_t v_fd)
		: io_operation{operation_type::clunk}
		, fd{v_fd}
		{}
	};

	/**
	* @brief This operation removes a fileas soon as all its file descriptors are given back
	*/
	struct remove_operation : public io_operation {
		const gp::buffer<char*> target_path; ///< the target file
		const gp::optional<gp_config::file_descriptor_t> fd; ///< the relative root to use

		/**
		* @brief Construct a new remove operation object
		* 
		* @param path the path to the file to remove
		* @param v_fd a relative root that is used
		*/
		remove_operation(
			gp::buffer<char*> path, 
			gp::optional<gp_config::file_descriptor_t> v_fd
		)
		: io_operation{operation_type::remove}
		, target_path(path)
		, fd(v_fd)
		{}
	};

	/**
	* @brief This operation fetches metadata about a file
	*/
	struct stat_operation : public io_operation {
		const gp::buffer<char*> target_path; ///< the file to query metadata about
		const gp::optional<gp_config::file_descriptor_t> fd; ///< the relative root to use

		/**
		* @brief Construct a new stat operation object
		* 
		* @param path the path to the file to query about
		* @param v_fd a relative root that is used
		*/
		stat_operation(
			gp::buffer<char*> path, 
			gp::optional<gp_config::file_descriptor_t> v_fd
		)
		: io_operation{operation_type::stat}
		, target_path(path)
		, fd(v_fd)
		{}
	};

	/**
	* @brief This operation writes metadata about a file
	*/
	struct wstat_operation : public io_operation {
		const gp::buffer<char*> target_path; ///< the file to set metadata on
		const gp::optional<gp_config::file_descriptor_t> fd; ///< the relative root to use

		/**
		* @brief Construct a new wstat operation object
		* 
		* @param path the path to the file to write about
		* @param v_fd a relative root that is used
		*/
		wstat_operation(
			gp::buffer<char*> path, 
			gp::optional<gp_config::file_descriptor_t> v_fd
		)
		: io_operation{operation_type::wstat}
		, target_path(path)
		, fd(v_fd)
		{}
	};
}