def test_write():
client = HttpFsClient(
HOSTNAME,
PORT,
ca_file=None
)
fake_path = "/some/path"
fake_data = b"This is some bytes"
fake_offset = 1024
fake_fd = 0
# Fake _send_request
def fake_send_request(request_type, **kwargs):
for arg in ["uid", "gid"]:
assert arg in kwargs.keys()
assert request_type == HttpFsRequest.OP_WRITE
assert kwargs["file_descriptor"] == fake_fd
assert kwargs["data"] == base64.standard_b64encode(fake_data).decode("utf-8")
assert kwargs["offset"] == fake_offset
resp = HttpFsResponse()
resp._response_data["bytes_written"] = 10
return resp
client._send_request = fake_send_request
client.write(fake_path, fake_data, fake_offset, fh=fake_fd)
def test_send_request_with_api_key():
client = HttpFsClient(
HOSTNAME,
PORT,
api_key=FAKE_API_KEY,
ca_file=None
)
# Fake response from the server
fake_response = MagicMock()
fake_response.raise_for_status = MagicMock(return_value=None)
fake_response.headers = {
"Content-Type": "application/json",
"Server": "HttpFs"
}
fake_response.json = MagicMock(return_value={
"error_no": HttpFsResponse.ERR_NONE,
"response_data": {}
})
# Fake POST request method
def fake_post(server_url, **kwargs):
assert server_url == client._server_url
assert "Authorization" in kwargs["headers"] and kwargs["headers"]["Authorization"] == FAKE_API_KEY
assert kwargs["json"] == FAKE_POST_REQ
return fake_response
# Fake requests.session
fake_session = MagicMock()
fake_session.post = fake_post
client._http_keepalive_session = fake_session
client._send_request(FAKE_REQ_TYPE, **FAKE_REQ_ARGS)
def test_read():
client = HttpFsClient(
HOSTNAME,
PORT,
ca_file=None
)
fake_path = "/some/path"
fake_offset = 1024
fake_size = 512
fake_fd = 0
# Fake _send_request
def fake_send_request(request_type, **kwargs):
for arg in ["uid", "gid"]:
assert arg in kwargs.keys()
assert request_type == HttpFsRequest.OP_READ
assert kwargs["file_descriptor"] == fake_fd
assert kwargs["size"] == fake_size
assert kwargs["offset"] == fake_offset
resp = HttpFsResponse()
resp._response_data["bytes_read"] = bytes()
return resp
client._send_request = fake_send_request
client.read(fake_path, fake_size, fake_offset, fh=fake_fd)
def test_api_key():
if os.path.exists(CRED_STORE_FILE):
os.remove(CRED_STORE_FILE)
# Test that cli correctly generates an API key
cli_result = sp.run(shlex.split(
"bin/httpfs-cli add-api-key {}".format(CRED_STORE_FILE)),
stdout=sp.PIPE,
stderr=sp.PIPE,
env=os.environ)
try:
assert cli_result.returncode == 0
except:
raise AssertionError("[API Key Generation Failed] {}".format(
cli_result.stderr.decode("utf-8").strip()))
# Make sure cli correctly populates the new API key in the keystore
cred_store = TextCredStore(file_path=CRED_STORE_FILE)
api_key_str = cli_result.stdout.decode("utf-8").strip()
assert cred_store.has_cred(api_key_str)
client = HttpFsClient("localhost", 8080, api_key=api_key_str)
# Mock sending a request
FAKE_PATH = "/some/link"
# Fake response from the server
fake_response = MagicMock()
fake_response.raise_for_status = MagicMock(return_value=None)
fake_response.headers = {
"Content-Type": "application/json",
"Server": "HttpFs"
}
fake_response.json = MagicMock(
return_value={
"error_no": HttpFsResponse.ERR_NONE,
"response_data": {
"target": FAKE_PATH
}
})
def fake_post(server_url, **kwargs):
assert server_url == client._server_url
assert "Authorization" in kwargs["headers"] and kwargs["headers"][
"Authorization"] == api_key_str
assert kwargs["json"]["type"] == HttpFsRequest.OP_READLINK
assert kwargs["json"]["args"]["link_path"] == FAKE_PATH
return fake_response
client._http_keepalive_session.post = fake_post
client.readlink("/some/link")
os.remove(CRED_STORE_FILE)
def test_statfs():
client = HttpFsClient(
HOSTNAME,
PORT,
ca_file=None
)
fake_path = "/some/path"
# Fake _send_request
def fake_send_request(request_type, **kwargs):
assert request_type == HttpFsRequest.OP_STAT_FS
assert kwargs["path"] == fake_path
return HttpFsResponse()
client._send_request = fake_send_request
client.statfs(fake_path)
def test_release():
client = HttpFsClient(
HOSTNAME,
PORT,
ca_file=None
)
fake_path = "/"
fake_fd = 999
# Fake _send_request
def fake_send_request(request_type, **kwargs):
assert request_type == HttpFsRequest.OP_RELEASE
assert kwargs["file_descriptor"] == fake_fd
return HttpFsResponse()
client._send_request = fake_send_request
client.release(fake_path, fh=fake_fd)
def test_constructor_with_ssl(mocker):
client_w_ca = HttpFsClient(
HOSTNAME,
PORT,
ca_file="test-file.crt"
)
assert client_w_ca.server_hostname == HOSTNAME
assert client_w_ca._server_url.startswith("https")
def test_flush():
client = HttpFsClient(
HOSTNAME,
PORT,
ca_file=None
)
fake_path = "/some/path"
fake_fd = 1234
# Fake _send_request
def fake_send_request(request_type, **kwargs):
assert request_type == HttpFsRequest.OP_FLUSH
assert kwargs["file_descriptor"] == fake_fd
return HttpFsResponse()
client._send_request = fake_send_request
client.flush(fake_path, fake_fd)
def test_mkdir():
client = HttpFsClient(
HOSTNAME,
PORT,
ca_file=None
)
fake_path = "/some/path"
fake_mode = 0o644
# Fake _send_request
def fake_send_request(request_type, **kwargs):
assert request_type == HttpFsRequest.OP_MKDIR
assert kwargs["path"] == fake_path
assert kwargs["mode"] == fake_mode
return HttpFsResponse()
client._send_request = fake_send_request
client.mkdir(fake_path, fake_mode)
def test_chown():
client = HttpFsClient(
HOSTNAME,
PORT,
ca_file=None
)
fake_path = "/some/path"
# Fake _send_request
def fake_send_request(request_type, **kwargs):
assert request_type == HttpFsRequest.OP_CHOWN
assert kwargs["path"] == fake_path
assert kwargs["uid"] == 2222
assert kwargs["gid"] == 0
return HttpFsResponse()
client._send_request = fake_send_request
client.chown(fake_path, 2222, 0)
def test_readlink():
client = HttpFsClient(
HOSTNAME,
PORT,
ca_file=None
)
fake_path = "/some/path"
# Fake _send_request
def fake_send_request(request_type, **kwargs):
assert request_type == HttpFsRequest.OP_READLINK
assert kwargs["link_path"] == fake_path
resp = HttpFsResponse()
resp._response_data["target"] = ""
return resp
client._send_request = fake_send_request
client.readlink(fake_path)
def test_truncate():
client = HttpFsClient(
HOSTNAME,
PORT,
ca_file=None
)
fake_path = "/some/path"
fake_len = 16
# Fake _send_request
def fake_send_request(request_type, **kwargs):
assert request_type == HttpFsRequest.OP_TRUNCATE
assert kwargs["path"] == fake_path
assert kwargs["length"] == fake_len
return HttpFsResponse()
client._send_request = fake_send_request
client.truncate(fake_path, fake_len)
def test_unlink():
client = HttpFsClient(
HOSTNAME,
PORT,
ca_file=None
)
fake_path = "/some/path"
# Fake _send_request
def fake_send_request(request_type, **kwargs):
for arg in ["uid", "gid"]:
assert arg in kwargs.keys()
assert request_type == HttpFsRequest.OP_UNLINK
assert kwargs["path"] == fake_path
return HttpFsResponse()
client._send_request = fake_send_request
client.unlink(fake_path)
def test_symlink():
client = HttpFsClient(
HOSTNAME,
PORT,
ca_file=None
)
fake_source = "/some/source"
fake_target = "/some/target"
# Fake _send_request
def fake_send_request(request_type, **kwargs):
assert request_type == HttpFsRequest.OP_SYMLINK
assert kwargs["target"] == fake_target
assert kwargs["source"] == fake_source
return HttpFsResponse()
client._send_request = fake_send_request
client.symlink(fake_target, fake_source)
def test_fsync():
client = HttpFsClient(
HOSTNAME,
PORT,
ca_file=None
)
fake_path = "/some/path"
fake_fd = 1234
fake_ds = True
# Fake _send_request
def fake_send_request(request_type, **kwargs):
assert request_type == HttpFsRequest.OP_FSYNC
assert kwargs["file_descriptor"] == fake_fd
assert kwargs["datasync"] == fake_ds
return HttpFsResponse()
client._send_request = fake_send_request
client.fsync(fake_path, fh=fake_fd, datasync=fake_ds)
def test_chmod():
client = HttpFsClient(
HOSTNAME,
PORT,
ca_file=None
)
fake_path = "/some/path"
fake_mode = 0o600
# Fake _send_request
def fake_send_request(request_type, **kwargs):
assert request_type == HttpFsRequest.OP_CHMOD
for required_key in ["uid", "gid"]:
assert required_key in kwargs.keys()
assert kwargs["path"] == fake_path
assert kwargs["mode"] == fake_mode
return HttpFsResponse()
client._send_request = fake_send_request
client.chmod(fake_path, fake_mode)
def test_constructor_without_ssl():
client = HttpFsClient(
HOSTNAME,
PORT,
ca_file=None
)
assert client.server_hostname == HOSTNAME
assert client._server_url == EXPECTED_URL
assert client._api_key == None
client = HttpFsClient(
HOSTNAME,
PORT,
api_key=FAKE_API_KEY,
ca_file=None
)
assert client.server_hostname == HOSTNAME
assert client._server_url == EXPECTED_URL
assert client._api_key == FAKE_API_KEY
def test_utimens():
client = HttpFsClient(
HOSTNAME,
PORT,
ca_file=None
)
fake_path = "/some/path"
fake_times = (0, 0)
# Fake _send_request
def fake_send_request(request_type, **kwargs):
for arg in ["uid", "gid"]:
assert arg in kwargs.keys()
assert request_type == HttpFsRequest.OP_UTIMENS
assert kwargs["path"] == fake_path
assert kwargs["times"] == fake_times
return HttpFsResponse()
client._send_request = fake_send_request
client.utimens(fake_path, times=fake_times)
def test_mknod():
client = HttpFsClient(
HOSTNAME,
PORT,
ca_file=None
)
fake_path = "/some/path"
fake_mode = 0o644
fake_dev = False
# Fake _send_request
def fake_send_request(request_type, **kwargs):
assert request_type == HttpFsRequest.OP_MKNOD
assert kwargs["path"] == fake_path
assert kwargs["mode"] == fake_mode
assert kwargs["dev"] == fake_dev
return HttpFsResponse()
client._send_request = fake_send_request
client.mknod(fake_path, fake_mode, fake_dev)
def test_rename():
client = HttpFsClient(
HOSTNAME,
PORT,
ca_file=None
)
fake_old_path = "/old-path"
fake_new_path = "/new-path"
# Fake _send_request
def fake_send_request(request_type, **kwargs):
for arg in ["uid", "gid"]:
assert arg in kwargs.keys()
assert request_type == HttpFsRequest.OP_RENAME
assert kwargs["old_path"] == fake_old_path
assert kwargs["new_path"] == fake_new_path
return HttpFsResponse()
client._send_request = fake_send_request
client.rename(fake_old_path, fake_new_path)
def test_open():
client = HttpFsClient(
HOSTNAME,
PORT,
ca_file=None
)
fake_path = "/some/path"
fake_flags = 0 | 1 | 2 | 666
# Fake _send_request
def fake_send_request(request_type, **kwargs):
for arg in ["uid", "gid"]:
assert arg in kwargs.keys()
assert request_type == HttpFsRequest.OP_OPEN
assert kwargs["path"] == fake_path
assert kwargs["flags"] == fake_flags
return HttpFsResponse()
client._send_request = fake_send_request
client.open(fake_path, fake_flags)
def test_readdir():
client = HttpFsClient(
HOSTNAME,
PORT,
ca_file=None
)
fake_path = "/some/path"
# Fake _send_request
def fake_send_request(request_type, **kwargs):
for arg in ["uid", "gid"]:
assert arg in kwargs.keys()
assert request_type == HttpFsRequest.OP_READDIR
assert kwargs["path"] == fake_path
resp = HttpFsResponse()
resp._response_data["dir_listing"] = list()
return resp
client._send_request = fake_send_request
client.readdir(fake_path)
def test_create():
client = HttpFsClient(
HOSTNAME,
PORT,
ca_file=None
)
fake_path = "/some/path"
fake_mode = 0o600
# Fake _send_request
def fake_send_request(request_type, **kwargs):
assert request_type == HttpFsRequest.OP_CREATE
for required_key in ["uid", "gid"]:
assert required_key in kwargs.keys()
assert kwargs["path"] == fake_path
assert kwargs["mode"] == fake_mode
resp = HttpFsResponse()
resp._response_data["file_descriptor"] = 0
return resp
client._send_request = fake_send_request
client.create(fake_path, fake_mode)
PARSER.add_argument("--verbose",
dest="verbose",
help="Be verbose",
action="store_true")
ARGS = PARSER.parse_args()
log_level = logging.WARN
if ARGS.verbose:
log_level = logging.DEBUG
logging.basicConfig(level=log_level, format=LOG_FMT, datefmt=DATE_FMT)
try:
# Create the mount directory
if not os.path.exists(ARGS.mount):
logging.error("Mount point '%s' does not exist", ARGS.mount)
sys.exit(1)
[HOSTNAME, PORT] = ARGS.server.rsplit(':', 1)
# Mount the filesystem
FUSE(HttpFsClient(HOSTNAME,
PORT,
api_key=ARGS.api_key,
ca_file=ARGS.ca_file),
ARGS.mount,
foreground=True,
allow_other=True)
except Exception as exception:
logging.error("ERROR: %s", exception)
