4213b96d3a
The way the registry was previously written if two concurrent uploads of the same blob were happening one would fail to grab the lock and then return early. The uploading client would then immediately HEAD the blob and if it did so quickly enough would get a short size or 404. To avoid this we need the upload to continue until all concurrent uploads are complete. To make this happen we treat upload chunks separately per upload so that separate uploads cannot overwrite the chunks once they are moved to the blob directory. We end up moving the chunks to the blob directory in upload specific locations to facilitate this. Once that is done we can atomically update the actual blob data from the chunks. In the filesystem driver we concatenate the chunks into the blob then atomically rename the result into its final blob/data location. This ensures that we only ever return valid HEAD info for a blob, and that it is only requested by the client once it exists. This should be safe because the objects are hashsum addresses which means their contents should be identical. If we end up moving one copy into place then another atomically they will always have the same data and size. These logs from an OpenDev test job seem to capture this in action: # First upload is completing and grabs the lock 2022-02-25 21:28:14,514 INFO registry.api: [u: 935f8eddbb9a4dab8dd8cc45ce7f9384] Upload final chunk _local opendevorg/gerrit digest sha256:0c6b8ff8c37e92eb1ca65ed8917e818927d5bf318b6f18896049b5d9afc28343 2022-02-25 21:28:14,576 DEBUG registry.storage: [u: 935f8eddbb9a4dab8dd8cc45ce7f9384] Locked digest sha256:0c6b8ff8c37e92eb1ca65ed8917e818927d5bf318b6f18896049b5d9afc28343 # Second upload attempts to complete but ends early without the lock 2022-02-25 21:28:15,517 INFO registry.api: [u: e817d8fd6c464f80bf405581e580cbab] Upload final chunk _local opendevorg/gerrit digest sha256:0c6b8ff8c37e92eb1ca65ed8917e818927d5bf318b6f18896049b5d9afc28343 2022-02-25 21:28:15,578 WARNING registry.storage: [u: e817d8fd6c464f80bf405581e580cbab] Failed to obtain lock(1) on digest sha256:0c6b8ff8c37e92eb1ca65ed8917e818927d5bf318b6f18896049b5d9afc28343 2022-02-25 21:28:15,588 INFO registry.api: [u: e817d8fd6c464f80bf405581e580cbab] Upload complete _local opendevorg/gerrit digest sha256:0c6b8ff8c37e92eb1ca65ed8917e818927d5bf318b6f18896049b5d9afc28343 2022-02-25 21:28:15,589 INFO cherrypy.access.140551593545056: ::ffff:172.17.0.1 - - [25/Feb/2022:21:28:15] "PUT /v2/opendevorg/gerrit/blobs/uploads/e817d8fd6c464f80bf405581e580cbab?digest=sha256%3A0c6b8ff8c37e92eb1ca65ed8917e818927d5bf318b6f18896049b5d9afc28343 HTTP/1.1" 201 - "" "docker/20.10.12 go/go1.16.12 git-commit/459d0df kernel/5.4.0-100-generic os/linux arch/amd64 UpstreamClient(Docker-Client/20.10.12 \(linux\))" # Second upload completion triggers the HEAD requests that is either a # 404 or short read. This causes the second upload client to error. 2022-02-25 21:28:15,605 INFO registry.api: Head blob _local opendevorg/gerrit sha256:0c6b8ff8c37e92eb1ca65ed8917e818927d5bf318b6f18896049b5d9afc28343 not found 2022-02-25 21:28:15,607 INFO cherrypy.access.140551593545056: ::ffff:172.17.0.1 - - [25/Feb/2022:21:28:15] "HEAD /v2/opendevorg/gerrit/blobs/sha256:0c6b8ff8c37e92eb1ca65ed8917e818927d5bf318b6f18896049b5d9afc28343 HTTP/1.1" 404 735 "" "docker/20.10.12 go/go1.16.12 git-commit/459d0df kernel/5.4.0-100-generic os/linux arch/amd64 UpstreamClient(Docker-Client/20.10.12 \(linux\))" # Now first upload has completed and the HEAD request by the first # upload client is successful 2022-02-25 21:28:18,898 INFO registry.api: [u: 935f8eddbb9a4dab8dd8cc45ce7f9384] Upload complete _local opendevorg/gerrit digest sha256:0c6b8ff8c37e92eb1ca65ed8917e818927d5bf318b6f18896049b5d9afc28343 2022-02-25 21:28:18,898 INFO cherrypy.access.140551593545056: ::ffff:172.17.0.1 - - [25/Feb/2022:21:28:18] "PUT /v2/opendevorg/gerrit/blobs/uploads/935f8eddbb9a4dab8dd8cc45ce7f9384?digest=sha256%3A0c6b8ff8c37e92eb1ca65ed8917e818927d5bf318b6f18896049b5d9afc28343 HTTP/1.1" 201 - "" "docker/20.10.12 go/go1.16.12 git-commit/459d0df kernel/5.4.0-100-generic os/linux arch/amd64 UpstreamClient(Docker-Client/20.10.12 \(linux\))" 2022-02-25 21:28:18,915 INFO registry.api: Head blob _local opendevorg/gerrit sha256:0c6b8ff8c37e92eb1ca65ed8917e818927d5bf318b6f18896049b5d9afc28343 size 54917164 2022-02-25 21:28:18,916 INFO cherrypy.access.140551593545056: ::ffff:172.17.0.1 - - [25/Feb/2022:21:28:18] "HEAD /v2/opendevorg/gerrit/blobs/sha256:0c6b8ff8c37e92eb1ca65ed8917e818927d5bf318b6f18896049b5d9afc28343 HTTP/1.1" 200 54917164 "" "docker/20.10.12 go/go1.16.12 git-commit/459d0df kernel/5.4.0-100-generic os/linux arch/amd64 UpstreamClient(Docker-Client/20.10.12 \(linux\))" Change-Id: Ibdf1ca554756af61247d705b2ea3cf85c39c2b83
139 lines
5.0 KiB
Python
139 lines
5.0 KiB
Python
# Copyright 2019 Red Hat, Inc.
|
|
#
|
|
# This module is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This software is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this software. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
import os
|
|
import tempfile
|
|
|
|
from . import storageutils
|
|
|
|
|
|
DISK_CHUNK_SIZE = 64 * 1024
|
|
|
|
|
|
class FilesystemDriver(storageutils.StorageDriver):
|
|
def __init__(self, conf):
|
|
self.root = conf['root']
|
|
|
|
def list_objects(self, path):
|
|
path = os.path.join(self.root, path)
|
|
if not os.path.isdir(path):
|
|
return []
|
|
ret = []
|
|
for f in os.listdir(path):
|
|
obj_path = os.path.join(path, f)
|
|
ret.append(storageutils.ObjectInfo(
|
|
obj_path, f, os.stat(obj_path).st_ctime,
|
|
os.path.isdir(obj_path)))
|
|
return ret
|
|
|
|
def get_object_size(self, path):
|
|
path = os.path.join(self.root, path)
|
|
if not os.path.exists(path):
|
|
return None
|
|
return os.stat(path).st_size
|
|
|
|
def put_object(self, path, data, uuid=None):
|
|
path = os.path.join(self.root, path)
|
|
os.makedirs(os.path.dirname(path), exist_ok=True)
|
|
with open(path, 'wb') as f:
|
|
if isinstance(data, bytes):
|
|
f.write(data)
|
|
else:
|
|
for chunk in data:
|
|
f.write(chunk)
|
|
f.flush()
|
|
os.fsync(f.fileno())
|
|
|
|
def get_object(self, path):
|
|
path = os.path.join(self.root, path)
|
|
if not os.path.exists(path):
|
|
return None
|
|
with open(path, 'rb') as f:
|
|
return f.read()
|
|
|
|
def stream_object(self, path):
|
|
path = os.path.join(self.root, path)
|
|
if not os.path.exists(path):
|
|
return None, None
|
|
f = open(path, 'rb', buffering=DISK_CHUNK_SIZE)
|
|
try:
|
|
size = os.fstat(f.fileno()).st_size
|
|
except OSError:
|
|
f.close()
|
|
raise
|
|
|
|
def data_iter(f=f):
|
|
with f:
|
|
yield b'' # will get discarded; see note below
|
|
yield from iter(lambda: f.read(DISK_CHUNK_SIZE), b'')
|
|
|
|
ret = data_iter()
|
|
# This looks a little funny, because it is. We're going to discard the
|
|
# empty bytes added at the start, but that's not the important part.
|
|
# We want to ensure that
|
|
#
|
|
# 1. the generator has started executing and
|
|
# 2. it left off *inside the with block*
|
|
#
|
|
# This ensures that when the generator gets cleaned up (either because
|
|
# everything went according to plan and the generator exited cleanly
|
|
# *or* there was an error which eventually raised a GeneratorExit),
|
|
# the file we opened will get closed.
|
|
next(ret)
|
|
return size, ret
|
|
|
|
def delete_object(self, path):
|
|
path = os.path.join(self.root, path)
|
|
if os.path.exists(path):
|
|
if os.path.isdir(path):
|
|
os.rmdir(path)
|
|
else:
|
|
os.unlink(path)
|
|
|
|
def move_object(self, src_path, dst_path, uuid=None):
|
|
src_path = os.path.join(self.root, src_path)
|
|
dst_path = os.path.join(self.root, dst_path)
|
|
os.makedirs(os.path.dirname(dst_path), exist_ok=True)
|
|
os.rename(src_path, dst_path)
|
|
|
|
def cat_objects(self, path, chunks, uuid=None):
|
|
path = os.path.join(self.root, path)
|
|
os.makedirs(os.path.dirname(path), exist_ok=True)
|
|
# We write to a temporary file in the same directory as the destiation
|
|
# file to ensure that we can rename it atomically once fully written.
|
|
# This is important because there may be multiple concurrent writes to
|
|
# the same object and due to client behavior we cannot return until
|
|
# at least one write is completed. To facilitate this we ensure each
|
|
# write happens completely then make that safe with atomic renames.
|
|
with tempfile.NamedTemporaryFile(dir=os.path.dirname(path),
|
|
delete=False) as outf:
|
|
for chunk in chunks:
|
|
chunk_path = os.path.join(self.root, chunk['path'])
|
|
with open(chunk_path, 'rb') as inf:
|
|
while True:
|
|
d = inf.read(4096)
|
|
if not d:
|
|
break
|
|
outf.write(d)
|
|
outf.flush()
|
|
os.fsync(outf.fileno())
|
|
os.rename(outf.name, path)
|
|
for chunk in chunks:
|
|
chunk_path = os.path.join(self.root, chunk['path'])
|
|
os.unlink(chunk_path)
|
|
|
|
|
|
Driver = FilesystemDriver
|