\u6839\u636eRFC 7233\u7b2c4.1\u8282，206 Partial Content\u72b6\u6001\u7801\u7684\u5b9a\u4e49\u5982\u4e0b：<\/p>\n
"206 (Partial Content)\u72b6\u6001\u7801\u8868\u793a\u670d\u52a1\u5668\u6b63\u5728\u6210\u529f\u6267\u884c\u4e00\u4e2a\u6216\u591a\u4e2a\u5b57\u8282\u8303\u56f4\u8bf7\u6c42，\u56e0\u4e3a\u8bf7\u6c42\u5305\u542bRange\u8bf7\u6c42\u5934\u90e8\u5b57\u6bb5（\u7b2c3.1\u8282）\u3002\u54cd\u5e94\u5fc5\u987b\u5305\u542bContent-Range\u5934\u90e8\u5b57\u6bb5（\u7b2c4.2\u8282），\u8bf4\u660e\u54cd\u5e94\u8868\u793a\u4e2d\u5305\u542b\u7684\u8303\u56f4，\u6216\u8005\u4f7f\u7528multipart\/byteranges\u5a92\u4f53\u7c7b\u578b\u548c\u6bcf\u4e2a\u90e8\u5206\u90fd\u5305\u542b\u81ea\u5df1\u7684Content-Range\u5b57\u6bb5\u3002"<\/p>\n
\u8303\u56f4\u8bf7\u6c42\u652f\u6301：\u5ba2\u6237\u7aef\u53ef\u4ee5\u8bf7\u6c42\u8d44\u6e90\u7684\u7279\u5b9a\u90e8\u5206<\/p>\n<\/li>\n
\u591a\u8303\u56f4\u54cd\u5e94：\u53ef\u4ee5\u540c\u65f6\u8bf7\u6c42\u591a\u4e2a\u4e0d\u8fde\u7eed\u7684\u8303\u56f4<\/p>\n<\/li>\n
\u6062\u590d\u4e0b\u8f7d：\u652f\u6301\u65ad\u70b9\u7eed\u4f20\u548c\u5e76\u884c\u4e0b\u8f7d<\/p>\n<\/li>\n
\u9ad8\u6548\u4f20\u8f93：\u51cf\u5c11\u4e0d\u5fc5\u8981\u7684\u6570\u636e\u4f20\u8f93<\/p>\n<\/li>\n
python<\/p>\n
# 206 Partial Content\u9002\u7528\u573a\u666f\u5206\u6790\u5668
\nclass PartialContentUseCaseAnalyzer:
\n """\u5206\u6790206\u72b6\u6001\u7801\u7684\u9002\u7528\u573a\u666f"""<\/p>\n
SCENARIOS = {
\n "resumable_downloads": {
\n "description": "\u53ef\u6062\u590d\u7684\u6587\u4ef6\u4e0b\u8f7d",
\n "examples": [
\n "\u5927\u6587\u4ef6\u4e0b\u8f7d\u4e2d\u65ad\u540e\u6062\u590d",
\n "\u7f51\u7edc\u4e0d\u7a33\u5b9a\u65f6\u7684\u5206\u7247\u4e0b\u8f7d",
\n "\u6d4f\u89c8\u5668\u4e0b\u8f7d\u7ba1\u7406\u5668",
\n "\u79fb\u52a8\u5e94\u7528\u4e2d\u7684\u5a92\u4f53\u4e0b\u8f7d"
\n ],
\n "range_type": "\u5355\u8303\u56f4\u6216\u8fde\u7eed\u8303\u56f4",
\n "typical_usage": "Range: bytes=1000-2000"
\n },
\n "streaming_media": {
\n "description": "\u6d41\u5a92\u4f53\u64ad\u653e",
\n "examples": [
\n "\u89c6\u9891\u64ad\u653e\u5668\u8df3\u8f6c\u65f6\u95f4\u70b9",
\n "\u97f3\u9891\u64ad\u653e\u5668\u968f\u673a\u8bbf\u95ee",
\n "\u5728\u7ebf\u89c6\u9891\u9884\u89c8",
\n "\u6d41\u5a92\u4f53\u670d\u52a1\u5668"
\n ],
\n "range_type": "\u5355\u8303\u56f4",
\n "typical_usage": "Range: bytes=0-1023 (\u521d\u59cb\u7247\u6bb5)"
\n },
\n "parallel_downloads": {
\n "description": "\u5e76\u884c\u4e0b\u8f7d\u52a0\u901f",
\n "examples": [
\n "\u4e0b\u8f7d\u7ba1\u7406\u5668\u5206\u5757\u4e0b\u8f7d",
\n "BitTorrent\u5ba2\u6237\u7aef",
\n "\u591a\u7ebf\u7a0b\u4e0b\u8f7d\u5de5\u5177",
\n "CDN\u8fb9\u7f18\u8282\u70b9\u540c\u6b65"
\n ],
\n "range_type": "\u591a\u8303\u56f4",
\n "typical_usage": "Range: bytes=0-999,2000-2999,5000-5999"
\n },
\n "data_sampling": {
\n "description": "\u5927\u6570\u636e\u91c7\u6837",
\n "examples": [
\n "\u5927\u578b\u65e5\u5fd7\u6587\u4ef6\u67e5\u770b",
\n "\u6570\u636e\u5e93\u5907\u4efd\u6587\u4ef6\u68c0\u67e5",
\n "\u5a92\u4f53\u6587\u4ef6\u5143\u6570\u636e\u8bfb\u53d6",
\n "\u6587\u4ef6\u683c\u5f0f\u9a8c\u8bc1"
\n ],
\n "range_type": "\u5355\u8303\u56f4",
\n "typical_usage": "Range: bytes=0-511 (\u8bfb\u53d6\u6587\u4ef6\u5934)"
\n },
\n "efficient_updates": {
\n "description": "\u9ad8\u6548\u589e\u91cf\u66f4\u65b0",
\n "examples": [
\n "\u6e38\u620f\u8865\u4e01\u4e0b\u8f7d",
\n "\u8f6f\u4ef6\u589e\u91cf\u66f4\u65b0",
\n "\u6570\u636e\u96c6\u589e\u91cf\u540c\u6b65",
\n "\u6587\u6863\u7248\u672c\u5dee\u5f02"
\n ],
\n "range_type": "\u5355\u8303\u56f4\u6216\u591a\u4e2a\u5355\u8303\u56f4",
\n "typical_usage": "Range: bytes=5000-"
\n }
\n }<\/p>\n
def analyze_request(self, request_headers, resource_size):
\n """
\n \u5206\u6790\u8303\u56f4\u8bf7\u6c42<\/p>\n
Args:
\n request_headers: \u8bf7\u6c42\u5934\u90e8\u5b57\u5178
\n resource_size: \u8d44\u6e90\u603b\u5927\u5c0f（\u5b57\u8282）<\/p>\n
Returns:
\n \u5206\u6790\u7ed3\u679c\u5b57\u5178
\n """
\n range_header = request_headers.get('Range')<\/p>\n
if not range_header:
\n return {
\n 'is_range_request': False,
\n 'recommendation': '\u4f7f\u7528\u5e38\u89c4\u8bf7\u6c42'
\n }<\/p>\n
try:
\n parsed_ranges = self._parse_range_header(range_header, resource_size)<\/p>\n
analysis = {
\n 'is_range_request': True,
\n 'range_type': 'single' if len(parsed_ranges) == 1 else 'multiple',
\n 'ranges': parsed_ranges,
\n 'total_size': resource_size,
\n 'recommended_response': self._recommend_response_type(parsed_ranges)
\n }<\/p>\n
# \u68c0\u67e5\u573a\u666f\u9002\u914d\u6027
\n analysis['scenarios'] = self._match_scenarios(parsed_ranges, resource_size)<\/p>\n
return analysis<\/p>\n
except ValueError as e:
\n return {
\n 'is_range_request': True,
\n 'error': str(e),
\n 'recommendation': '\u8fd4\u56de416 Range Not Satisfiable'
\n }<\/p>\n
def _parse_range_header(self, range_header, resource_size):
\n """\u89e3\u6790Range\u5934\u90e8"""
\n if not range_header.startswith('bytes='):
\n raise ValueError('Only byte ranges are supported')<\/p>\n
ranges_str = range_header[6:] # \u79fb\u9664'bytes='
\n range_specs = ranges_str.split(',')<\/p>\n
parsed_ranges = []<\/p>\n
for spec in range_specs:
\n spec = spec.strip()<\/p>\n
if '-' not in spec:
\n raise ValueError(f'Invalid range spec: {spec}')<\/p>\n
start_str, end_str = spec.split('-', 1)<\/p>\n
if start_str == '' and end_str == '':
\n raise ValueError('Empty range spec')<\/p>\n
# \u5904\u7406\u4e0d\u540c\u7c7b\u578b\u7684\u8303\u56f4
\n if start_str == '':
\n # suffix-byte-range-spec: \u6700\u540eN\u5b57\u8282
\n suffix_length = int(end_str)
\n if suffix_length <= 0:
\n raise ValueError('Suffix length must be positive')<\/p>\n
start = max(0, resource_size – suffix_length)
\n end = resource_size – 1<\/p>\n
elif end_str == '':
\n # \u4ecestart\u5230\u7ed3\u5c3e
\n start = int(start_str)
\n if start >= resource_size:
\n raise ValueError(f'Start {start} beyond resource size {resource_size}')
\n end = resource_size – 1<\/p>\n
else:
\n # \u5b8c\u6574\u7684\u8303\u56f4
\n start = int(start_str)
\n end = int(end_str)<\/p>\n
if start > end:
\n raise ValueError(f'Start {start} greater than end {end}')<\/p>\n
if start >= resource_size:
\n raise ValueError(f'Start {start} beyond resource size {resource_size}')<\/p>\n
# \u8c03\u6574\u7ed3\u675f\u4f4d\u7f6e\u4e0d\u8d85\u8fc7\u8d44\u6e90\u5927\u5c0f
\n end = min(end, resource_size – 1)<\/p>\n
# \u786e\u4fdd\u8303\u56f4\u6709\u6548
\n if start < 0 or end < 0 or start > end:
\n raise ValueError(f'Invalid range: {start}-{end}')<\/p>\n
parsed_ranges.append({
\n 'start': start,
\n 'end': end,
\n 'length': end – start + 1,
\n 'spec': spec
\n })<\/p>\n
return parsed_ranges<\/p>\n
def _recommend_response_type(self, ranges):
\n """\u63a8\u8350\u54cd\u5e94\u7c7b\u578b"""
\n if len(ranges) == 1:
\n return {
\n 'status': 206,
\n 'content_type': 'application\/octet-stream',
\n 'headers': ['Content-Range'],
\n 'body_type': 'single_part'
\n }
\n else:
\n return {
\n 'status': 206,
\n 'content_type': 'multipart\/byteranges; boundary=',
\n 'headers': ['Content-Type', 'Content-Length'],
\n 'body_type': 'multipart'
\n }<\/p>\n
def _match_scenarios(self, ranges, resource_size):
\n """\u5339\u914d\u9002\u7528\u573a\u666f"""
\n matched = []<\/p>\n
# \u68c0\u67e5\u662f\u5426\u9002\u5408\u6d41\u5a92\u4f53
\n if len(ranges) == 1:
\n range_length = ranges[0]['length']
\n if range_length <= 1024 * 1024: # 1MB\u4ee5\u4e0b
\n matched.append('streaming_media')<\/p>\n
# \u68c0\u67e5\u662f\u5426\u9002\u5408\u5e76\u884c\u4e0b\u8f7d
\n if len(ranges) > 1:
\n matched.append('parallel_downloads')<\/p>\n
# \u68c0\u67e5\u662f\u5426\u9002\u5408\u6062\u590d\u4e0b\u8f7d
\n for r in ranges:
\n if r['start'] > 0:
\n matched.append('resumable_downloads')
\n break<\/p>\n
# \u68c0\u67e5\u662f\u5426\u9002\u5408\u6570\u636e\u91c7\u6837
\n if len(ranges) == 1 and ranges[0]['length'] < 1024: # \u5c0f\u4e8e1KB
\n matched.append('data_sampling')<\/p>\n
return list(set(matched)) # \u53bb\u91cd<\/p>\n
python<\/p>\n
# Range\u5934\u90e8\u89e3\u6790\u5668
\nclass RangeHeaderParser:
\n """\u89e3\u6790\u548c\u9a8c\u8bc1Range\u8bf7\u6c42\u5934\u90e8"""<\/p>\n
def __init__(self, max_ranges=10, max_range_length=100*1024*1024): # 100MB
\n self.max_ranges = max_ranges
\n self.max_range_length = max_range_length<\/p>\n
def parse(self, range_header, content_length):
\n """
\n \u89e3\u6790Range\u5934\u90e8<\/p>\n
Args:
\n range_header: Range\u5934\u90e8\u503c
\n content_length: \u5185\u5bb9\u957f\u5ea6<\/p>\n
Returns:
\n {
\n 'valid': bool,
\n 'ranges': list,
\n 'error': str,
\n 'content_range': str (\u7528\u4e8e416\u54cd\u5e94)
\n }
\n """
\n if not range_header:
\n return {
\n 'valid': False,
\n 'error': 'No Range header provided',
\n 'content_range': f'bytes *\/{content_length}'
\n }<\/p>\n
if not range_header.startswith('bytes='):
\n return {
\n 'valid': False,
\n 'error': 'Only byte ranges are supported',
\n 'content_range': f'bytes *\/{content_length}'
\n }<\/p>\n
# \u63d0\u53d6\u8303\u56f4\u89c4\u683c
\n ranges_str = range_header[6:] # \u79fb\u9664'bytes='
\n range_specs = [s.strip() for s in ranges_str.split(',')]<\/p>\n
# \u68c0\u67e5\u6570\u91cf\u9650\u5236
\n if len(range_specs) > self.max_ranges:
\n return {
\n 'valid': False,
\n 'error': f'Too many ranges (max {self.max_ranges})',
\n 'content_range': f'bytes *\/{content_length}'
\n }<\/p>\n
parsed_ranges = []
\n valid_ranges = []<\/p>\n
for i, spec in enumerate(range_specs):
\n result = self._parse_single_range(spec, content_length)<\/p>\n
if not result['valid']:
\n # \u5355\u4e2a\u8303\u56f4\u65e0\u6548，\u6574\u4e2a\u8bf7\u6c42\u65e0\u6548
\n return {
\n 'valid': False,
\n 'error': f'Invalid range spec {i+1}: {result["error"]}',
\n 'content_range': f'bytes *\/{content_length}'
\n }<\/p>\n
parsed_ranges.append(result)<\/p>\n
# \u68c0\u67e5\u8303\u56f4\u957f\u5ea6\u9650\u5236
\n if result['length'] > self.max_range_length:
\n return {
\n 'valid': False,
\n 'error': f'Range {i+1} too large (max {self.max_range_length} bytes)',
\n 'content_range': f'bytes *\/{content_length}'
\n }<\/p>\n
# \u6dfb\u52a0\u5230\u6709\u6548\u8303\u56f4\u5217\u8868
\n valid_ranges.append({
\n 'start': result['start'],
\n 'end': result['end'],
\n 'length': result['length']
\n })<\/p>\n
# \u68c0\u67e5\u8303\u56f4\u91cd\u53e0\u548c\u6392\u5e8f
\n sorted_ranges = sorted(valid_ranges, key=lambda x: x['start'])
\n for i in range(1, len(sorted_ranges)):
\n if sorted_ranges[i]['start'] <= sorted_ranges[i-1]['end']:
\n return {
\n 'valid': False,
\n 'error': f'Overlapping ranges: {sorted_ranges[i-1]} and {sorted_ranges[i]}',
\n 'content_range': f'bytes *\/{content_length}'
\n }<\/p>\n
return {
\n 'valid': True,
\n 'ranges': sorted_ranges,
\n 'total_length': content_length,
\n 'requested_ranges': len(range_specs)
\n }<\/p>\n
def _parse_single_range(self, spec, content_length):
\n """\u89e3\u6790\u5355\u4e2a\u8303\u56f4\u89c4\u683c"""<\/p>\n
if '-' not in spec:
\n return {
\n 'valid': False,
\n 'error': f'Invalid format: {spec}'
\n }<\/p>\n
start_str, end_str = spec.split('-', 1)<\/p>\n
try:
\n # \u540e\u7f00\u5b57\u8282\u8303\u56f4\u89c4\u683c (\u4f8b\u5982: -500)
\n if start_str == '':
\n if not end_str.isdigit():
\n return {
\n 'valid': False,
\n 'error': f'Invalid suffix: {end_str}'
\n }<\/p>\n
suffix_length = int(end_str)
\n if suffix_length <= 0:
\n return {
\n 'valid': False,
\n 'error': f'Suffix must be positive: {suffix_length}'
\n }<\/p>\n
start = max(0, content_length – suffix_length)
\n end = content_length – 1<\/p>\n
# \u5f00\u59cb\u5230\u7ed3\u675f\u7684\u8303\u56f4 (\u4f8b\u5982: 1000-2000)
\n elif end_str == '':
\n if not start_str.isdigit():
\n return {
\n 'valid': False,
\n 'error': f'Invalid start: {start_str}'
\n }<\/p>\n
start = int(start_str)
\n if start >= content_length:
\n return {
\n 'valid': False,
\n 'error': f'Start {start} beyond content length {content_length}'
\n }
\n end = content_length – 1<\/p>\n
# \u5b8c\u6574\u7684\u8303\u56f4\u89c4\u683c
\n else:
\n if not (start_str.isdigit() and end_str.isdigit()):
\n return {
\n 'valid': False,
\n 'error': f'Invalid start or end: {start_str}-{end_str}'
\n }<\/p>\n
start = int(start_str)
\n end = int(end_str)<\/p>\n
if start > end:
\n return {
\n 'valid': False,
\n 'error': f'Start {start} greater than end {end}'
\n }<\/p>\n
if start >= content_length:
\n return {
\n 'valid': False,
\n 'error': f'Start {start} beyond content length {content_length}'
\n }<\/p>\n
# \u8c03\u6574\u7ed3\u675f\u4f4d\u7f6e
\n end = min(end, content_length – 1)<\/p>\n
# \u6700\u7ec8\u9a8c\u8bc1
\n if start < 0 or end < 0 or start > end:
\n return {
\n 'valid': False,
\n 'error': f'Invalid range: {start}-{end}'
\n }<\/p>\n
return {
\n 'valid': True,
\n 'start': start,
\n 'end': end,
\n 'length': end – start + 1,
\n 'spec': spec
\n }<\/p>\n
except ValueError:
\n return {
\n 'valid': False,
\n 'error': f'Invalid range spec: {spec}'
\n }<\/p>\n
def generate_content_range(self, start, end, total_length):
\n """\u751f\u6210Content-Range\u5934\u90e8\u503c"""
\n return f'bytes {start}-{end}\/{total_length}'<\/p>\n
def generate_416_content_range(self, total_length):
\n """\u751f\u6210416\u54cd\u5e94\u7684Content-Range\u5934\u90e8\u503c"""
\n return f'bytes *\/{total_length}'<\/p>\n
# \u4f7f\u7528\u793a\u4f8b
\nparser = RangeHeaderParser()<\/p>\n
# \u6d4b\u8bd5\u5404\u79cdRange\u5934\u90e8
\ntest_cases = [
\n ("bytes=0-499", 1000),
\n ("bytes=500-999", 1000),
\n ("bytes=-500", 1000), # \u6700\u540e500\u5b57\u8282
\n ("bytes=950-", 1000), # \u4ece950\u5230\u7ed3\u5c3e
\n ("bytes=0-0", 1000), # \u7b2c\u4e00\u4e2a\u5b57\u8282
\n ("bytes=2-5,10-15", 1000), # \u591a\u4e2a\u8303\u56f4
\n ("bytes=1000-2000", 500), # \u65e0\u6548：\u5f00\u59cb\u8d85\u51fa\u8303\u56f4
\n ("bytes=200-100", 1000), # \u65e0\u6548：\u5f00\u59cb>\u7ed3\u675f
\n ("bytes=abc-def", 1000), # \u65e0\u6548：\u975e\u6570\u5b57
\n]<\/p>\n
for range_header, content_length in test_cases:
\n print(f"\\\\nRange: {range_header}, Content-Length: {content_length}")
\n result = parser.parse(range_header, content_length)<\/p>\n
if result['valid']:
\n print(f" \u6709\u6548\u8303\u56f4: {result['ranges']}")
\n else:
\n print(f" \u65e0\u6548: {result['error']}")
\n print(f" 416 Content-Range: {result.get('content_range', 'N\/A')}")<\/p>\n
python<\/p>\n
# Content-Range\u5934\u90e8\u751f\u6210\u5668
\nclass ContentRangeHeaderBuilder:
\n """\u751f\u6210Content-Range\u54cd\u5e94\u5934\u90e8"""<\/p>\n
@staticmethod
\n def for_single_range(start, end, total_length):
\n """\u5355\u4e2a\u8303\u56f4\u7684Content-Range"""
\n if start < 0 or end < 0 or start > end or end >= total_length:
\n raise ValueError(f"Invalid range: {start}-{end}\/{total_length}")<\/p>\n
return f"bytes {start}-{end}\/{total_length}"<\/p>\n
@staticmethod
\n def for_multipart_boundary(boundary):
\n """\u591a\u90e8\u5206\u54cd\u5e94\u7684Content-Type"""
\n return f"multipart\/byteranges; boundary={boundary}"<\/p>\n
@staticmethod
\n def for_part_in_multipart(start, end, total_length, content_type="application\/octet-stream"):
\n """\u591a\u90e8\u5206\u54cd\u5e94\u4e2d\u6bcf\u4e2a\u90e8\u5206\u7684\u5934\u90e8"""
\n headers = [
\n f"Content-Range: bytes {start}-{end}\/{total_length}",
\n f"Content-Type: {content_type}"
\n ]
\n return "\\\\r\\\\n".join(headers)<\/p>\n
@staticmethod
\n def for_unsatisfiable_range(total_length):
\n """416\u54cd\u5e94\u7684Content-Range"""
\n return f"bytes *\/{total_length}"<\/p>\n
# \u5b8c\u6574206\u54cd\u5e94\u751f\u6210\u5668
\nclass PartialContentResponseBuilder:
\n """\u6784\u5efa206 Partial Content\u54cd\u5e94"""<\/p>\n
def __init__(self, resource_path, resource_size, mime_type="application\/octet-stream"):
\n self.resource_path = resource_path
\n self.resource_size = resource_size
\n self.mime_type = mime_type
\n self.range_parser = RangeHeaderParser()<\/p>\n
def build_response(self, range_header, request_headers=None):
\n """
\n \u6784\u5efa206\u54cd\u5e94<\/p>\n
Args:
\n range_header: Range\u8bf7\u6c42\u5934\u90e8\u503c
\n request_headers: \u5b8c\u6574\u7684\u8bf7\u6c42\u5934\u90e8\u5b57\u5178<\/p>\n
Returns:
\n (status_code, headers, body_generator)
\n """
\n # \u89e3\u6790Range\u5934\u90e8
\n parse_result = self.range_parser.parse(range_header, self.resource_size)<\/p>\n
if not parse_result['valid']:
\n # \u8fd4\u56de416 Range Not Satisfiable
\n return 416, {
\n 'Content-Range': parse_result.get('content_range', f'bytes *\/{self.resource_size}'),
\n 'Content-Type': 'text\/plain'
\n }, b'Requested range not satisfiable'<\/p>\n
ranges = parse_result['ranges']<\/p>\n
# \u5982\u679c\u662f\u5355\u4e2a\u8303\u56f4
\n if len(ranges) == 1:
\n return self._build_single_range_response(ranges[0], request_headers)
\n else:
\n return self._build_multipart_response(ranges, request_headers)<\/p>\n
def _build_single_range_response(self, range_info, request_headers):
\n """\u6784\u5efa\u5355\u4e2a\u8303\u56f4\u54cd\u5e94"""
\n start = range_info['start']
\n end = range_info['end']
\n length = range_info['length']<\/p>\n
headers = {
\n 'Content-Range': ContentRangeHeaderBuilder.for_single_range(
\n start, end, self.resource_size
\n ),
\n 'Content-Length': str(length),
\n 'Content-Type': self.mime_type,
\n 'Accept-Ranges': 'bytes',
\n 'ETag': self._generate_etag(),
\n 'Last-Modified': self._get_last_modified(),
\n 'Cache-Control': 'public, max-age=31536000', # \u53ef\u7f13\u5b581\u5e74
\n }<\/p>\n
# \u6dfb\u52a0\u6761\u4ef6\u8bf7\u6c42\u652f\u6301
\n if request_headers:
\n self._add_conditional_headers(headers, request_headers)<\/p>\n
# \u521b\u5efa\u751f\u6210\u5668\u6765\u8bfb\u53d6\u6587\u4ef6\u90e8\u5206
\n def body_generator():
\n with open(self.resource_path, 'rb') as f:
\n f.seek(start)
\n remaining = length
\n chunk_size = 64 * 1024 # 64KB\u5757<\/p>\n
while remaining > 0:
\n read_size = min(chunk_size, remaining)
\n chunk = f.read(read_size)
\n if not chunk:
\n break
\n yield chunk
\n remaining -= len(chunk)<\/p>\n
return 206, headers, body_generator()<\/p>\n
def _build_multipart_response(self, ranges, request_headers):
\n """\u6784\u5efa\u591a\u90e8\u5206\u8303\u56f4\u54cd\u5e94"""
\n boundary = f"boundary_{hash(str(ranges))}_{int(time.time())}"
\n content_type = f"multipart\/byteranges; boundary={boundary}"<\/p>\n
# \u9996\u5148\u8ba1\u7b97\u603b\u957f\u5ea6
\n total_length = self._calculate_multipart_length(ranges, boundary)<\/p>\n
headers = {
\n 'Content-Type': content_type,
\n 'Content-Length': str(total_length),
\n 'Accept-Ranges': 'bytes',
\n 'ETag': self._generate_etag(),
\n 'Cache-Control': 'no-store', # \u591a\u90e8\u5206\u54cd\u5e94\u901a\u5e38\u4e0d\u7f13\u5b58
\n }<\/p>\n
def body_generator():
\n with open(self.resource_path, 'rb') as f:
\n for i, range_info in enumerate(ranges):
\n # \u6bcf\u4e2a\u90e8\u5206\u7684\u8fb9\u754c
\n yield f"\\\\r\\\\n–{boundary}\\\\r\\\\n".encode()<\/p>\n
# \u90e8\u5206\u5934\u90e8
\n part_headers = ContentRangeHeaderBuilder.for_part_in_multipart(
\n range_info['start'], range_info['end'],
\n self.resource_size, self.mime_type
\n )
\n yield f"{part_headers}\\\\r\\\\n\\\\r\\\\n".encode()<\/p>\n
# \u90e8\u5206\u5185\u5bb9
\n f.seek(range_info['start'])
\n remaining = range_info['length']
\n chunk_size = 64 * 1024<\/p>\n
while remaining > 0:
\n read_size = min(chunk_size, remaining)
\n chunk = f.read(read_size)
\n if not chunk:
\n break
\n yield chunk
\n remaining -= len(chunk)<\/p>\n
# \u7ed3\u675f\u8fb9\u754c
\n yield f"\\\\r\\\\n–{boundary}–\\\\r\\\\n".encode()<\/p>\n
return 206, headers, body_generator()<\/p>\n
def _calculate_multipart_length(self, ranges, boundary):
\n """\u8ba1\u7b97\u591a\u90e8\u5206\u54cd\u5e94\u7684\u603b\u957f\u5ea6"""
\n total = 0<\/p>\n
for range_info in ranges:
\n # \u8fb9\u754c\u884c
\n total += len(f"\\\\r\\\\n–{boundary}\\\\r\\\\n")<\/p>\n
# \u5934\u90e8
\n part_headers = ContentRangeHeaderBuilder.for_part_in_multipart(
\n range_info['start'], range_info['end'],
\n self.resource_size, self.mime_type
\n )
\n total += len(f"{part_headers}\\\\r\\\\n\\\\r\\\\n")<\/p>\n
# \u5185\u5bb9
\n total += range_info['length']<\/p>\n
# \u7ed3\u675f\u8fb9\u754c
\n total += len(f"\\\\r\\\\n–{boundary}–\\\\r\\\\n")<\/p>\n
return total<\/p>\n
def _generate_etag(self):
\n """\u751f\u6210ETag（\u793a\u4f8b\u5b9e\u73b0）"""
\n import hashlib
\n import os<\/p>\n
stat = os.stat(self.resource_path)
\n content = f"{self.resource_path}:{stat.st_size}:{stat.st_mtime}"
\n return f'"{hashlib.md5(content.encode()).hexdigest()}"'<\/p>\n
def _get_last_modified(self):
\n """\u83b7\u53d6\u6700\u540e\u4fee\u6539\u65f6\u95f4"""
\n import os
\n from datetime import datetime<\/p>\n
mtime = os.path.getmtime(self.resource_path)
\n return datetime.fromtimestamp(mtime).strftime('%a, %d %b %Y %H:%M:%S GMT')<\/p>\n
def _add_conditional_headers(self, response_headers, request_headers):
\n """\u6dfb\u52a0\u6761\u4ef6\u8bf7\u6c42\u76f8\u5173\u5934\u90e8"""
\n # \u68c0\u67e5If-Range
\n if 'If-Range' in request_headers:
\n # \u8fd9\u91cc\u5e94\u8be5\u9a8c\u8bc1If-Range\u6761\u4ef6
\n # \u5982\u679c\u6761\u4ef6\u4e0d\u6ee1\u8db3，\u5e94\u8be5\u8fd4\u56de\u6574\u4e2a\u8d44\u6e90\u800c\u4e0d\u662f\u90e8\u5206\u5185\u5bb9
\n pass<\/p>\n
# \u68c0\u67e5If-Match\/If-None-Match
\n if 'If-Match' in request_headers or 'If-None-Match' in request_headers:
\n response_headers['Vary'] = 'If-Match, If-None-Match'<\/p>\n
nginx<\/p>\n
# Nginx\u90e8\u5206\u5185\u5bb9\u54cd\u5e94\u914d\u7f6e
\nhttp {
\n # \u542f\u7528\u5b57\u8282\u8303\u56f4\u652f\u6301
\n slice 1m; # \u5207\u7247\u5927\u5c0f，\u7528\u4e8e\u89c6\u9891\u6d41
\n proxy_cache_path \/var\/cache\/nginx levels=1:2 keys_zone=video_cache:10m
\n max_size=10g inactive=60m use_temp_path=off;<\/p>\n
# \u89c6\u9891\u6d41\u670d\u52a1\u5668\u914d\u7f6e
\n server {
\n listen 80;
\n server_name video.example.com;<\/p>\n
location \/videos\/ {
\n # \u542f\u7528\u8303\u56f4\u8bf7\u6c42\u652f\u6301
\n mp4;
\n mp4_buffer_size 1m;
\n mp4_max_buffer_size 5m;<\/p>\n
# \u9650\u5236\u8bf7\u6c42\u901f\u7387
\n limit_rate 100m; # \u6700\u5927100MB\/s
\n limit_rate_after 10m; # 10MB\u540e\u5f00\u59cb\u9650\u901f<\/p>\n
# \u7f13\u5b58\u63a7\u5236
\n add_header Cache-Control "public, max-age=31536000";
\n add_header Accept-Ranges bytes;
\n add_header X-Content-Type-Options nosniff;<\/p>\n
# \u8bbf\u95ee\u63a7\u5236
\n satisfy any;
\n allow 192.168.1.0\/24;
\n deny all;<\/p>\n
# \u4ee3\u7406\u8bbe\u7f6e
\n proxy_pass http:\/\/video_backend;
\n proxy_set_header Range $http_range;
\n proxy_set_header If-Range $http_if_range;<\/p>\n
# \u7f13\u51b2\u548c\u8d85\u65f6
\n proxy_buffering on;
\n proxy_buffer_size 128k;
\n proxy_buffers 4 256k;
\n proxy_busy_buffers_size 256k;
\n proxy_read_timeout 300;
\n }<\/p>\n
# \u5927\u6587\u4ef6\u4e0b\u8f7d\u914d\u7f6e
\n location \/downloads\/ {
\n # \u57fa\u7840\u8bbe\u7f6e
\n root \/var\/www;
\n autoindex off;<\/p>\n
# \u8303\u56f4\u8bf7\u6c42\u652f\u6301
\n add_header Accept-Ranges bytes;<\/p>\n
# \u5b89\u5168\u5934\u90e8
\n add_header X-Content-Type-Options nosniff;
\n add_header X-Frame-Options DENY;
\n add_header X-XSS-Protection "1; mode=block";<\/p>\n
# \u4e0b\u8f7d\u9650\u5236
\n limit_rate 50m; # \u9650\u5236\u4e0b\u8f7d\u901f\u5ea6
\n limit_rate_after 100m; # 100MB\u540e\u9650\u901f<\/p>\n
# \u9632\u76d7\u94fe
\n valid_referers none blocked server_names *.example.com;
\n if ($invalid_referer) {
\n return 403;
\n }<\/p>\n
# \u6587\u4ef6\u7c7b\u578b\u5904\u7406
\n location ~* \\\\.(mp4|avi|mkv|mov)$ {
\n # \u89c6\u9891\u6587\u4ef6\u7279\u6b8a\u5904\u7406
\n add_header Cache-Control "public, max-age=604800"; # 7\u5929
\n }<\/p>\n
location ~* \\\\.(zip|rar|7z|tar\\\\.gz)$ {
\n # \u538b\u7f29\u6587\u4ef6
\n add_header Content-Disposition "attachment";
\n add_header Cache-Control "no-cache";
\n }
\n }<\/p>\n
# API\u7aef\u70b9\u5904\u7406\u8303\u56f4\u8bf7\u6c42
\n location \/api\/files\/ {
\n # \u4ee3\u7406\u5230\u5e94\u7528\u670d\u52a1\u5668
\n proxy_pass http:\/\/app_backend;<\/p>\n
# \u4f20\u9012\u8303\u56f4\u76f8\u5173\u5934\u90e8
\n proxy_set_header Range $http_range;
\n proxy_set_header If-Range $http_if_range;
\n proxy_set_header X-Original-Range $http_range;<\/p>\n
# \u5904\u7406\u5e94\u7528\u670d\u52a1\u5668\u7684206\u54cd\u5e94
\n proxy_intercept_errors on;
\n error_page 416 = @handle_416;<\/p>\n
# \u7f13\u51b2\u8bbe\u7f6e
\n proxy_buffering on;
\n proxy_buffer_size 4k;
\n proxy_buffers 8 4k;<\/p>\n
# \u8d85\u65f6\u8bbe\u7f6e
\n proxy_connect_timeout 60;
\n proxy_send_timeout 300;
\n proxy_read_timeout 300;
\n }<\/p>\n
# 416\u9519\u8bef\u5904\u7406
\n location @handle_416 {
\n default_type application\/json;
\n return 416 '{"error": "Requested range not satisfiable"}';
\n }
\n }<\/p>\n
# \u4e0a\u6e38\u670d\u52a1\u5668\u914d\u7f6e
\n upstream video_backend {
\n server 192.168.1.100:8080;
\n server 192.168.1.101:8080;
\n keepalive 32;
\n }<\/p>\n
upstream app_backend {
\n server 192.168.1.200:8000;
\n server 192.168.1.201:8000;
\n keepalive 16;
\n }
\n}<\/p>\n
# \u7279\u6b8a\u60c5\u51b5\u5904\u7406
\nevents {
\n worker_connections 1024;
\n use epoll;
\n}<\/p>\n
python<\/p>\n
# \u5b8c\u6574\u7684206 Partial Content\u670d\u52a1\u5668\u5b9e\u73b0
\nfrom flask import Flask, request, Response, send_file, jsonify
\nimport os
\nimport mimetypes
\nfrom datetime import datetime
\nimport hashlib
\nimport time
\nfrom functools import wraps
\nimport re<\/p>\n
app = Flask(__name__)<\/p>\n
# \u914d\u7f6e
\napp.config['MAX_CONTENT_LENGTH'] = 100 * 1024 * 1024 * 1024 # 100GB\u6700\u5927\u6587\u4ef6
\napp.config['RANGE_REQUEST_MAX_RANGES'] = 10
\napp.config['RANGE_REQUEST_MAX_SIZE'] = 100 * 1024 * 1024 # 100MB\u6700\u5927\u8303\u56f4
\napp.config['CHUNK_SIZE'] = 64 * 1024 # 64KB\u5757\u5927\u5c0f<\/p>\n
class RangeRequestHandler:
\n """\u5904\u7406\u8303\u56f4\u8bf7\u6c42\u7684\u5904\u7406\u5668"""<\/p>\n
def __init__(self, file_path, mime_type=None):
\n self.file_path = file_path
\n self.mime_type = mime_type or self._guess_mime_type(file_path)
\n self.file_size = os.path.getsize(file_path)
\n self.last_modified = datetime.fromtimestamp(
\n os.path.getmtime(file_path)
\n )
\n self.etag = self._generate_etag()<\/p>\n
def _guess_mime_type(self, file_path):
\n """\u731c\u6d4bMIME\u7c7b\u578b"""
\n mime_type, _ = mimetypes.guess_type(file_path)
\n return mime_type or 'application\/octet-stream'<\/p>\n
def _generate_etag(self):
\n """\u751f\u6210ETag"""
\n stat = os.stat(self.file_path)
\n content = f"{self.file_path}:{stat.st_size}:{stat.st_mtime}"
\n return f'"{hashlib.md5(content.encode()).hexdigest()}"'<\/p>\n
def handle_request(self, range_header=None):
\n """\u5904\u7406HTTP\u8bf7\u6c42"""<\/p>\n
# \u68c0\u67e5\u6761\u4ef6\u8bf7\u6c42
\n if not self._check_conditions():
\n return self._build_conditional_failure_response()<\/p>\n
# \u5982\u679c\u6ca1\u6709Range\u5934\u90e8，\u8fd4\u56de\u6574\u4e2a\u6587\u4ef6
\n if not range_header:
\n return self._serve_full_file()<\/p>\n
# \u89e3\u6790Range\u5934\u90e8
\n ranges = self._parse_range_header(range_header)
\n if not ranges:
\n return self._build_range_not_satisfiable_response()<\/p>\n
# \u5904\u7406\u8303\u56f4\u8bf7\u6c42
\n if len(ranges) == 1:
\n return self._serve_single_range(ranges[0])
\n else:
\n return self._serve_multipart_ranges(ranges)<\/p>\n
def _check_conditions(self):
\n """\u68c0\u67e5\u6761\u4ef6\u8bf7\u6c42\u5934\u90e8"""
\n # \u68c0\u67e5If-Match
\n if_match = request.headers.get('If-Match')
\n if if_match and self.etag not in self._parse_etag_list(if_match):
\n return False<\/p>\n
# \u68c0\u67e5If-None-Match
\n if_none_match = request.headers.get('If-None-Match')
\n if if_none_match and self.etag in self._parse_etag_list(if_none_match):
\n # \u5bf9\u4e8eGET\/HEAD，\u8fd4\u56de304；\u5bf9\u4e8e\u5176\u4ed6\u65b9\u6cd5，\u8fd4\u56de412
\n if request.method in ('GET', 'HEAD'):
\n return None # \u7279\u6b8a\u6807\u8bb0，\u8868\u793a304
\n return False<\/p>\n
# \u68c0\u67e5If-Modified-Since
\n if_modified_since = request.headers.get('If-Modified-Since')
\n if if_modified_since:
\n try:
\n since = datetime.strptime(
\n if_modified_since, '%a, %d %b %Y %H:%M:%S GMT'
\n )
\n if self.last_modified <= since:
\n return None # \u7279\u6b8a\u6807\u8bb0，\u8868\u793a304
\n except ValueError:
\n pass<\/p>\n
# \u68c0\u67e5If-Unmodified-Since
\n if_unmodified_since = request.headers.get('If-Unmodified-Since')
\n if if_unmodified_since:
\n try:
\n since = datetime.strptime(
\n if_unmodified_since, '%a, %d %b %Y %H:%M:%S GMT'
\n )
\n if self.last_modified > since:
\n return False
\n except ValueError:
\n pass<\/p>\n
# \u68c0\u67e5If-Range（\u4ec5\u5728\u90e8\u5206\u8bf7\u6c42\u65f6\u68c0\u67e5）
\n if_range = request.headers.get('If-Range')
\n if if_range and request.headers.get('Range'):
\n # If-Range\u53ef\u4ee5\u662fETag\u6216\u65e5\u671f
\n if if_range.startswith('"'):
\n # ETag\u683c\u5f0f
\n if if_range != self.etag:
\n # \u8fd4\u56de\u6574\u4e2a\u8d44\u6e90
\n return self._serve_full_file()
\n else:
\n # \u65e5\u671f\u683c\u5f0f
\n try:
\n since = datetime.strptime(
\n if_range, '%a, %d %b %Y %H:%M:%S GMT'
\n )
\n if self.last_modified > since:
\n # \u8fd4\u56de\u6574\u4e2a\u8d44\u6e90
\n return self._serve_full_file()
\n except ValueError:
\n pass<\/p>\n
return True<\/p>\n
def _parse_etag_list(self, etag_header):
\n """\u89e3\u6790ETag\u5217\u8868"""
\n etags = []
\n for etag in etag_header.split(','):
\n etag = etag.strip()
\n if etag:
\n etags.append(etag)
\n return etags<\/p>\n
def _parse_range_header(self, range_header):
\n """\u89e3\u6790Range\u5934\u90e8"""
\n if not range_header.startswith('bytes='):
\n return None<\/p>\n
range_str = range_header[6:] # \u79fb\u9664'bytes='
\n range_specs = [s.strip() for s in range_str.split(',')]<\/p>\n
# \u9650\u5236\u8303\u56f4\u6570\u91cf
\n if len(range_specs) > app.config['RANGE_REQUEST_MAX_RANGES']:
\n return None<\/p>\n
ranges = []<\/p>\n
for spec in range_specs:
\n range_info = self._parse_single_range(spec)
\n if not range_info:
\n return None<\/p>\n
# \u68c0\u67e5\u8303\u56f4\u5927\u5c0f\u9650\u5236
\n range_length = range_info['end'] – range_info['start'] + 1
\n if range_length > app.config['RANGE_REQUEST_MAX_SIZE']:
\n return None<\/p>\n
ranges.append(range_info)<\/p>\n
# \u68c0\u67e5\u8303\u56f4\u91cd\u53e0\u548c\u6392\u5e8f
\n ranges.sort(key=lambda x: x['start'])
\n for i in range(1, len(ranges)):
\n if ranges[i]['start'] <= ranges[i-1]['end']:
\n return None<\/p>\n
return ranges<\/p>\n
def _parse_single_range(self, range_spec):
\n """\u89e3\u6790\u5355\u4e2a\u8303\u56f4\u89c4\u683c"""
\n if '-' not in range_spec:
\n return None<\/p>\n
start_str, end_str = range_spec.split('-', 1)<\/p>\n
try:
\n # \u540e\u7f00\u8303\u56f4\u89c4\u683c
\n if start_str == '':
\n suffix_length = int(end_str)
\n if suffix_length <= 0:
\n return None<\/p>\n
start = max(0, self.file_size – suffix_length)
\n end = self.file_size – 1<\/p>\n
# \u5f00\u59cb\u5230\u7ed3\u5c3e
\n elif end_str == '':
\n start = int(start_str)
\n if start >= self.file_size:
\n return None
\n end = self.file_size – 1<\/p>\n
# \u5b8c\u6574\u8303\u56f4
\n else:
\n start = int(start_str)
\n end = int(end_str)<\/p>\n
if start > end:
\n return None<\/p>\n
if start >= self.file_size:
\n return None<\/p>\n
# \u8c03\u6574\u7ed3\u675f\u4f4d\u7f6e
\n end = min(end, self.file_size – 1)<\/p>\n
# \u9a8c\u8bc1\u6700\u7ec8\u8303\u56f4
\n if start < 0 or end < 0 or start > end:
\n return None<\/p>\n
return {
\n 'start': start,
\n 'end': end,
\n 'length': end – start + 1
\n }<\/p>\n
except ValueError:
\n return None<\/p>\n
def _build_conditional_failure_response(self):
\n """\u6784\u5efa\u6761\u4ef6\u8bf7\u6c42\u5931\u8d25\u54cd\u5e94"""
\n if request.method in ('GET', 'HEAD'):
\n # 304 Not Modified
\n return Response(status=304, headers={
\n 'ETag': self.etag,
\n 'Last-Modified': self.last_modified.strftime('%a, %d %b %Y %H:%M:%S GMT')
\n })
\n else:
\n # 412 Precondition Failed
\n return Response('Precondition Failed', status=412)<\/p>\n
def _build_range_not_satisfiable_response(self):
\n """\u6784\u5efa416\u54cd\u5e94"""
\n return Response(
\n 'Requested range not satisfiable',
\n status=416,
\n headers={
\n 'Content-Range': f'bytes *\/{self.file_size}',
\n 'Content-Type': 'text\/plain'
\n }
\n )<\/p>\n
def _serve_full_file(self):
\n """\u63d0\u4f9b\u6574\u4e2a\u6587\u4ef6"""
\n headers = {
\n 'Content-Type': self.mime_type,
\n 'Content-Length': str(self.file_size),
\n 'Accept-Ranges': 'bytes',
\n 'ETag': self.etag,
\n 'Last-Modified': self.last_modified.strftime('%a, %d %b %Y %H:%M:%S GMT'),
\n 'Cache-Control': 'public, max-age=31536000' # 1\u5e74
\n }<\/p>\n
if request.method == 'HEAD':
\n return Response(headers=headers)<\/p>\n
return send_file(
\n self.file_path,
\n mimetype=self.mime_type,
\n as_attachment=False,
\n conditional=True
\n )<\/p>\n
def _serve_single_range(self, range_info):
\n """\u63d0\u4f9b\u5355\u4e2a\u8303\u56f4"""
\n start = range_info['start']
\n end = range_info['end']
\n length = range_info['length']<\/p>\n
headers = {
\n 'Content-Range': f'bytes {start}-{end}\/{self.file_size}',
\n 'Content-Length': str(length),
\n 'Content-Type': self.mime_type,
\n 'Accept-Ranges': 'bytes',
\n 'ETag': self.etag,
\n 'Cache-Control': 'public, max-age=31536000'
\n }<\/p>\n
if request.method == 'HEAD':
\n return Response(headers=headers)<\/p>\n
def generate():
\n with open(self.file_path, 'rb') as f:
\n f.seek(start)
\n remaining = length
\n chunk_size = app.config['CHUNK_SIZE']<\/p>\n
while remaining > 0:
\n read_size = min(chunk_size, remaining)
\n chunk = f.read(read_size)
\n if not chunk:
\n break
\n yield chunk
\n remaining -= len(chunk)<\/p>\n
return Response(
\n generate(),
\n status=206,
\n headers=headers
\n )<\/p>\n
def _serve_multipart_ranges(self, ranges):
\n """\u63d0\u4f9b\u591a\u90e8\u5206\u8303\u56f4"""
\n boundary = f"boundary_{hash(str(ranges))}_{int(time.time())}"
\n content_type = f"multipart\/byteranges; boundary={boundary}"<\/p>\n
# \u8ba1\u7b97\u603b\u957f\u5ea6
\n total_length = self._calculate_multipart_length(ranges, boundary)<\/p>\n
headers = {
\n 'Content-Type': content_type,
\n 'Content-Length': str(total_length),
\n 'Accept-Ranges': 'bytes',
\n 'ETag': self.etag,
\n 'Cache-Control': 'no-store' # \u591a\u90e8\u5206\u54cd\u5e94\u4e0d\u7f13\u5b58
\n }<\/p>\n
if request.method == 'HEAD':
\n return Response(headers=headers)<\/p>\n
def generate():
\n with open(self.file_path, 'rb') as f:
\n for i, range_info in enumerate(ranges):
\n # \u8fb9\u754c
\n yield f"\\\\r\\\\n–{boundary}\\\\r\\\\n".encode()<\/p>\n
# \u90e8\u5206\u5934\u90e8
\n part_headers = [
\n f"Content-Range: bytes {range_info['start']}-{range_info['end']}\/{self.file_size}",
\n f"Content-Type: {self.mime_type}"
\n ]
\n yield "\\\\r\\\\n".join(part_headers).encode()
\n yield "\\\\r\\\\n\\\\r\\\\n".encode()<\/p>\n
# \u90e8\u5206\u5185\u5bb9
\n f.seek(range_info['start'])
\n remaining = range_info['length']
\n chunk_size = app.config['CHUNK_SIZE']<\/p>\n
while remaining > 0:
\n read_size = min(chunk_size, remaining)
\n chunk = f.read(read_size)
\n if not chunk:
\n break
\n yield chunk
\n remaining -= len(chunk)<\/p>\n
# \u7ed3\u675f\u8fb9\u754c
\n yield f"\\\\r\\\\n–{boundary}–\\\\r\\\\n".encode()<\/p>\n
return Response(
\n generate(),
\n status=206,
\n headers=headers
\n )<\/p>\n
def _calculate_multipart_length(self, ranges, boundary):
\n """\u8ba1\u7b97\u591a\u90e8\u5206\u54cd\u5e94\u957f\u5ea6"""
\n total = 0<\/p>\n
for range_info in ranges:
\n # \u8fb9\u754c\u884c
\n total += len(f"\\\\r\\\\n–{boundary}\\\\r\\\\n")<\/p>\n
# \u5934\u90e8
\n headers = [
\n f"Content-Range: bytes {range_info['start']}-{range_info['end']}\/{self.file_size}",
\n f"Content-Type: {self.mime_type}"
\n ]
\n total += len("\\\\r\\\\n".join(headers)) + len("\\\\r\\\\n\\\\r\\\\n")<\/p>\n
# \u5185\u5bb9
\n total += range_info['length']<\/p>\n
# \u7ed3\u675f\u8fb9\u754c
\n total += len(f"\\\\r\\\\n–{boundary}–\\\\r\\\\n")<\/p>\n
return total<\/p>\n
# API\u7aef\u70b9
\n@app.route('\/api\/files\/<path:filename>')
\ndef serve_file(filename):
\n """\u63d0\u4f9b\u6587\u4ef6\u4e0b\u8f7d（\u652f\u6301\u8303\u56f4\u8bf7\u6c42）"""<\/p>\n
# \u5b89\u5168\u9a8c\u8bc1：\u9632\u6b62\u76ee\u5f55\u904d\u5386
\n safe_filename = os.path.basename(filename)
\n file_path = os.path.join(app.config['UPLOAD_FOLDER'], safe_filename)<\/p>\n
if not os.path.exists(file_path):
\n return jsonify({'error': 'File not found'}), 404<\/p>\n
# \u521b\u5efa\u5904\u7406\u5668
\n handler = RangeRequestHandler(file_path)<\/p>\n
# \u83b7\u53d6Range\u5934\u90e8
\n range_header = request.headers.get('Range')<\/p>\n
# \u5904\u7406\u8bf7\u6c42
\n return handler.handle_request(range_header)<\/p>\n
@app.route('\/api\/stream\/video\/<video_id>')
\ndef stream_video(video_id):
\n """\u6d41\u5f0f\u4f20\u8f93\u89c6\u9891（\u652f\u6301\u8303\u56f4\u8bf7\u6c42）"""<\/p>\n
# \u83b7\u53d6\u89c6\u9891\u6587\u4ef6\u8def\u5f84
\n video_path = get_video_path(video_id) # \u5047\u8bbe\u7684\u51fd\u6570
\n if not video_path or not os.path.exists(video_path):
\n return jsonify({'error': 'Video not found'}), 404<\/p>\n
# \u89c6\u9891\u6587\u4ef6\u7684MIME\u7c7b\u578b
\n mime_type = 'video\/mp4' # \u6839\u636e\u5b9e\u9645\u683c\u5f0f\u8c03\u6574<\/p>\n
# \u521b\u5efa\u5904\u7406\u5668
\n handler = RangeRequestHandler(video_path, mime_type)<\/p>\n
# \u83b7\u53d6Range\u5934\u90e8
\n range_header = request.headers.get('Range')<\/p>\n
# \u5904\u7406\u8bf7\u6c42
\n return handler.handle_request(range_header)<\/p>\n
# \u4e2d\u95f4\u4ef6：\u8bb0\u5f55\u8303\u56f4\u8bf7\u6c42\u7edf\u8ba1
\n@app.after_request
\ndef log_range_requests(response):
\n """\u8bb0\u5f55\u8303\u56f4\u8bf7\u6c42\u7edf\u8ba1"""
\n if request.headers.get('Range') and response.status_code == 206:
\n # \u8bb0\u5f55\u5230\u65e5\u5fd7
\n app.logger.info(f"Range request: {request.headers.get('Range')} -> {response.status}")<\/p>\n
# \u6dfb\u52a0\u81ea\u5b9a\u4e49\u5934\u90e8
\n response.headers['X-Range-Request'] = 'processed'<\/p>\n
# \u5982\u679c\u662f\u8303\u56f4\u54cd\u5e94，\u6dfb\u52a0\u7edf\u8ba1\u4fe1\u606f
\n content_range = response.headers.get('Content-Range')
\n if content_range:
\n # \u89e3\u6790\u8303\u56f4\u4fe1\u606f
\n match = re.match(r'bytes (\\\\d+)-(\\\\d+)\/(\\\\d+)', content_range)
\n if match:
\n start, end, total = match.groups()
\n bytes_served = int(end) – int(start) + 1
\n response.headers['X-Bytes-Served'] = str(bytes_served)
\n response.headers['X-Total-Bytes'] = total<\/p>\n
return response<\/p>\n
# \u8f85\u52a9\u51fd\u6570
\ndef get_video_path(video_id):
\n """\u83b7\u53d6\u89c6\u9891\u6587\u4ef6\u8def\u5f84（\u793a\u4f8b\u5b9e\u73b0）"""
\n # \u5b9e\u9645\u4e2d\u53ef\u80fd\u4f1a\u4ece\u6570\u636e\u5e93\u6216\u6587\u4ef6\u7cfb\u7edf\u4e2d\u67e5\u627e
\n video_dir = '\/var\/www\/videos'
\n for ext in ['.mp4', '.avi', '.mkv', '.mov']:
\n path = os.path.join(video_dir, f"{video_id}{ext}")
\n if os.path.exists(path):
\n return path
\n return None<\/p>\n
if __name__ == '__main__':
\n app.config['UPLOAD_FOLDER'] = '\/var\/www\/uploads'
\n os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)<\/p>\n
app.run(host='0.0.0.0', port=8000, threaded=True)<\/p>\n
javascript<\/p>\n
\/\/ \u6d4f\u89c8\u5668\u7aef\u8303\u56f4\u8bf7\u6c42\u5904\u7406\u5668
\nclass RangeRequestClient {
\n \/**
\n * \u6d4f\u89c8\u5668\u7aef\u8303\u56f4\u8bf7\u6c42\u5904\u7406\u5668
\n *\/<\/p>\n
constructor(options = {}) {
\n this.options = {
\n chunkSize: 1024 * 1024, \/\/ 1MB\u5757\u5927\u5c0f
\n maxRetries: 3,
\n retryDelay: 1000,
\n parallelDownloads: 3,
\n …options
\n };<\/p>\n
this.downloadQueue = [];
\n this.activeDownloads = 0;
\n this.downloadStats = new Map();
\n }<\/p>\n
\/**
\n * \u5206\u5757\u4e0b\u8f7d\u6587\u4ef6
\n * @param {string} url – \u6587\u4ef6URL
\n * @param {Object} options – \u4e0b\u8f7d\u9009\u9879
\n *\/
\n async downloadFile(url, options = {}) {
\n const {
\n onProgress,
\n onComplete,
\n onError,
\n resume = false
\n } = options;<\/p>\n
try {
\n \/\/ 1. \u83b7\u53d6\u6587\u4ef6\u4fe1\u606f
\n const fileInfo = await this.getFileInfo(url);
\n if (!fileInfo) {
\n throw new Error('\u65e0\u6cd5\u83b7\u53d6\u6587\u4ef6\u4fe1\u606f');
\n }<\/p>\n
\/\/ 2. \u68c0\u67e5\u662f\u5426\u652f\u6301\u8303\u56f4\u8bf7\u6c42
\n if (!fileInfo.acceptRanges) {
\n \/\/ \u56de\u9000\u5230\u666e\u901a\u4e0b\u8f7d
\n return await this.downloadFullFile(url, options);
\n }<\/p>\n
\/\/ 3. \u68c0\u67e5\u662f\u5426\u6709\u90e8\u5206\u4e0b\u8f7d\u7684\u6587\u4ef6
\n const downloadedParts = resume ? await this.getDownloadedParts(url, fileInfo) : [];<\/p>\n
\/\/ 4. \u8ba1\u7b97\u9700\u8981\u4e0b\u8f7d\u7684\u8303\u56f4
\n const ranges = this.calculateRanges(fileInfo.size, downloadedParts);<\/p>\n
\/\/ 5. \u5e76\u884c\u4e0b\u8f7d\u6240\u6709\u8303\u56f4
\n const chunks = await this.downloadRanges(url, ranges, {
\n onProgress: (chunkIndex, progress) => {
\n if (onProgress) {
\n const overallProgress = this.calculateOverallProgress(
\n ranges, chunkIndex, progress
\n );
\n onProgress(overallProgress);
\n }
\n }
\n });<\/p>\n
\/\/ 6. \u5408\u5e76\u6240\u6709\u5757
\n const blob = this.mergeChunks(chunks, fileInfo.size);<\/p>\n
\/\/ 7. \u6e05\u7406\u4e34\u65f6\u6570\u636e
\n await this.cleanupTempData(url);<\/p>\n
if (onComplete) {
\n onComplete(blob, fileInfo);
\n }<\/p>\n
return blob;<\/p>\n
} catch (error) {
\n if (onError) {
\n onError(error);
\n }
\n throw error;
\n }
\n }<\/p>\n
\/**
\n * \u83b7\u53d6\u6587\u4ef6\u4fe1\u606f
\n *\/
\n async getFileInfo(url) {
\n try {
\n const response = await fetch(url, {
\n method: 'HEAD',
\n headers: {
\n 'Accept': '*\/*'
\n }
\n });<\/p>\n
if (!response.ok) {
\n throw new Error(`HTTP ${response.status}`);
\n }<\/p>\n
const contentLength = response.headers.get('Content-Length');
\n const acceptRanges = response.headers.get('Accept-Ranges') === 'bytes';
\n const contentType = response.headers.get('Content-Type');
\n const lastModified = response.headers.get('Last-Modified');
\n const etag = response.headers.get('ETag');<\/p>\n
return {
\n size: parseInt(contentLength, 10) || 0,
\n acceptRanges,
\n contentType,
\n lastModified,
\n etag,
\n url
\n };<\/p>\n
} catch (error) {
\n console.error('Failed to get file info:', error);
\n return null;
\n }
\n }<\/p>\n
\/**
\n * \u83b7\u53d6\u5df2\u4e0b\u8f7d\u7684\u90e8\u5206
\n *\/
\n async getDownloadedParts(url, fileInfo) {
\n const storageKey = `download:${btoa(url)}`;<\/p>\n
try {
\n const saved = localStorage.getItem(storageKey);
\n if (!saved) {
\n return [];
\n }<\/p>\n
const data = JSON.parse(saved);<\/p>\n
\/\/ \u9a8c\u8bc1\u6587\u4ef6\u662f\u5426\u5df2\u66f4\u6539
\n if (data.etag !== fileInfo.etag ||
\n data.size !== fileInfo.size) {
\n localStorage.removeItem(storageKey);
\n return [];
\n }<\/p>\n
return data.parts || [];<\/p>\n
} catch (error) {
\n console.error('Failed to get downloaded parts:', error);
\n return [];
\n }
\n }<\/p>\n
\/**
\n * \u8ba1\u7b97\u9700\u8981\u4e0b\u8f7d\u7684\u8303\u56f4
\n *\/
\n calculateRanges(fileSize, downloadedParts) {
\n const ranges = [];<\/p>\n
if (downloadedParts.length === 0) {
\n \/\/ \u5168\u65b0\u4e0b\u8f7d：\u5c06\u6587\u4ef6\u5206\u6210\u591a\u4e2a\u5757
\n for (let start = 0; start < fileSize; start += this.options.chunkSize) {
\n const end = Math.min(start + this.options.chunkSize – 1, fileSize – 1);
\n ranges.push({ start, end, downloaded: false });
\n }
\n } else {
\n \/\/ \u6062\u590d\u4e0b\u8f7d：\u53ea\u4e0b\u8f7d\u7f3a\u5931\u7684\u90e8\u5206
\n let currentPos = 0;<\/p>\n
\/\/ \u6309\u5f00\u59cb\u4f4d\u7f6e\u6392\u5e8f
\n downloadedParts.sort((a, b) => a.start – b.start);<\/p>\n
for (const part of downloadedParts) {
\n if (currentPos < part.start) {
\n \/\/ \u7f3a\u5931\u7684\u90e8\u5206
\n ranges.push({
\n start: currentPos,
\n end: part.start – 1,
\n downloaded: false
\n });
\n }
\n \/\/ \u5df2\u4e0b\u8f7d\u7684\u90e8\u5206
\n ranges.push({
\n …part,
\n downloaded: true
\n });
\n currentPos = part.end + 1;
\n }<\/p>\n
\/\/ \u68c0\u67e5\u6700\u540e\u7684\u90e8\u5206
\n if (currentPos < fileSize) {
\n ranges.push({
\n start: currentPos,
\n end: fileSize – 1,
\n downloaded: false
\n });
\n }
\n }<\/p>\n
return ranges;
\n }<\/p>\n
\/**
\n * \u5e76\u884c\u4e0b\u8f7d\u8303\u56f4
\n *\/
\n async downloadRanges(url, ranges, callbacks) {
\n const chunks = new Array(ranges.length);
\n const errors = [];<\/p>\n
\/\/ \u53ea\u4e0b\u8f7d\u672a\u5b8c\u6210\u7684\u90e8\u5206
\n const rangesToDownload = ranges.filter(r => !r.downloaded);<\/p>\n
\/\/ \u521b\u5efa\u4e0b\u8f7d\u4efb\u52a1
\n const downloadTasks = rangesToDownload.map((range, index) => ({
\n index: ranges.indexOf(range),
\n range,
\n retries: 0
\n }));<\/p>\n
\/\/ \u5e76\u884c\u4e0b\u8f7d
\n await this.parallelDownload(url, downloadTasks, chunks, errors, callbacks);<\/p>\n
\/\/ \u5904\u7406\u5df2\u4e0b\u8f7d\u7684\u90e8\u5206
\n ranges.forEach((range, index) => {
\n if (range.downloaded) {
\n \/\/ \u4ecelocalStorage\u52a0\u8f7d\u5df2\u4e0b\u8f7d\u7684\u6570\u636e
\n const chunk = this.loadChunkFromStorage(url, range);
\n if (chunk) {
\n chunks[index] = chunk;
\n } else {
\n errors.push(`Failed to load chunk ${index} from storage`);
\n }
\n }
\n });<\/p>\n
if (errors.length > 0) {
\n throw new Error(`Download failed: ${errors.join(', ')}`);
\n }<\/p>\n
return chunks;
\n }<\/p>\n
\/**
\n * \u5e76\u884c\u4e0b\u8f7d\u5b9e\u73b0
\n *\/
\n async parallelDownload(url, tasks, chunks, errors, callbacks) {
\n return new Promise((resolve, reject) => {
\n let completed = 0;<\/p>\n
const processNext = () => {
\n \/\/ \u627e\u5230\u4e0b\u4e00\u4e2a\u672a\u5f00\u59cb\u7684\u4efb\u52a1
\n const task = tasks.find(t => !t.started && t.retries < this.options.maxRetries);<\/p>\n
if (!task) {
\n if (completed === tasks.length) {
\n resolve();
\n }
\n return;
\n }<\/p>\n
task.started = true;
\n this.activeDownloads++;<\/p>\n
this.downloadRange(url, task.range, task.retries)
\n .then(async (chunk) => {
\n chunks[task.index] = chunk;<\/p>\n
\/\/ \u4fdd\u5b58\u5230\u672c\u5730\u5b58\u50a8
\n await this.saveChunkToStorage(url, task.range, chunk);<\/p>\n
if (callbacks?.onProgress) {
\n callbacks.onProgress(task.index, 100);
\n }<\/p>\n
completed++;
\n this.activeDownloads–;<\/p>\n
\/\/ \u5904\u7406\u4e0b\u4e00\u4e2a\u4efb\u52a1
\n setTimeout(processNext, 0);
\n })
\n .catch(async (error) => {
\n console.error(`Failed to download range ${task.index}:`, error);<\/p>\n
task.retries++;
\n task.started = false;
\n this.activeDownloads–;<\/p>\n
if (task.retries >= this.options.maxRetries) {
\n errors.push(`Range ${task.range.start}-${task.range.end}: ${error.message}`);
\n }<\/p>\n
\/\/ \u5ef6\u8fdf\u540e\u91cd\u8bd5
\n setTimeout(processNext, this.options.retryDelay);
\n });
\n };<\/p>\n
\/\/ \u542f\u52a8\u521d\u59cb\u4e0b\u8f7d
\n for (let i = 0; i < Math.min(this.options.parallelDownloads, tasks.length); i++) {
\n setTimeout(processNext, 0);
\n }
\n });
\n }<\/p>\n
\/**
\n * \u4e0b\u8f7d\u5355\u4e2a\u8303\u56f4
\n *\/
\n async downloadRange(url, range, retryCount = 0) {
\n const rangeHeader = `bytes=${range.start}-${range.end}`;<\/p>\n
try {
\n const response = await fetch(url, {
\n headers: {
\n 'Range': rangeHeader,
\n 'Accept': '*\/*'
\n },
\n \/\/ \u6dfb\u52a0\u8d85\u65f6\u548c\u91cd\u8bd5\u903b\u8f91
\n signal: AbortSignal.timeout(30000) \/\/ 30\u79d2\u8d85\u65f6
\n });<\/p>\n
if (response.status === 206) {
\n const blob = await response.blob();<\/p>\n
\/\/ \u9a8c\u8bc1\u4e0b\u8f7d\u7684\u5927\u5c0f
\n if (blob.size !== range.end – range.start + 1) {
\n throw new Error(`Size mismatch: expected ${range.end – range.start + 1}, got ${blob.size}`);
\n }<\/p>\n
return blob;<\/p>\n
} else if (response.status === 416) {
\n \/\/ \u8303\u56f4\u4e0d\u53ef\u6ee1\u8db3，\u53ef\u80fd\u662f\u6587\u4ef6\u5df2\u66f4\u6539
\n throw new Error('Range not satisfiable – file may have changed');<\/p>\n
} else {
\n throw new Error(`HTTP ${response.status}`);
\n }<\/p>\n
} catch (error) {
\n if (retryCount < this.options.maxRetries – 1) {
\n console.log(`Retrying range ${range.start}-${range.end} (attempt ${retryCount + 2})`);
\n }
\n throw error;
\n }
\n }<\/p>\n
\/**
\n * \u5408\u5e76\u5757
\n *\/
\n mergeChunks(chunks, totalSize) {
\n \/\/ \u521b\u5efa\u4e00\u4e2a\u8db3\u591f\u5927\u7684ArrayBuffer
\n const buffer = new ArrayBuffer(totalSize);
\n const view = new Uint8Array(buffer);<\/p>\n
let offset = 0;<\/p>\n
for (const chunk of chunks) {
\n if (!chunk) {
\n throw new Error('Missing chunk');
\n }<\/p>\n
const chunkArray = new Uint8Array(chunk);
\n view.set(chunkArray, offset);
\n offset += chunkArray.length;
\n }<\/p>\n
return new Blob([buffer]);
\n }<\/p>\n
\/**
\n * \u4fdd\u5b58\u5757\u5230\u672c\u5730\u5b58\u50a8
\n *\/
\n async saveChunkToStorage(url, range, chunk) {
\n const storageKey = `download:${btoa(url)}`;<\/p>\n
try {
\n \/\/ \u5c06\u5757\u8f6c\u6362\u4e3abase64
\n const base64 = await this.blobToBase64(chunk);<\/p>\n
\/\/ \u83b7\u53d6\u73b0\u6709\u6570\u636e
\n const existing = localStorage.getItem(storageKey);
\n const data = existing ? JSON.parse(existing) : {
\n parts: [],
\n etag: null,
\n size: 0
\n };<\/p>\n
\/\/ \u66f4\u65b0\u90e8\u5206\u4fe1\u606f
\n const existingPartIndex = data.parts.findIndex(p =>
\n p.start === range.start && p.end === range.end
\n );<\/p>\n
if (existingPartIndex >= 0) {
\n data.parts[existingPartIndex].data = base64;
\n } else {
\n data.parts.push({
\n start: range.start,
\n end: range.end,
\n data: base64
\n });
\n }<\/p>\n
\/\/ \u4fdd\u5b58\u5230localStorage
\n localStorage.setItem(storageKey, JSON.stringify(data));<\/p>\n
} catch (error) {
\n console.error('Failed to save chunk:', error);
\n }
\n }<\/p>\n
\/**
\n * \u4ece\u672c\u5730\u5b58\u50a8\u52a0\u8f7d\u5757
\n *\/
\n loadChunkFromStorage(url, range) {
\n const storageKey = `download:${btoa(url)}`;<\/p>\n
try {
\n const saved = localStorage.getItem(storageKey);
\n if (!saved) return null;<\/p>\n
const data = JSON.parse(saved);
\n const part = data.parts.find(p =>
\n p.start === range.start && p.end === range.end
\n );<\/p>\n
if (!part || !part.data) return null;<\/p>\n
\/\/ \u5c06base64\u8f6c\u6362\u56deBlob
\n return this.base64ToBlob(part.data, 'application\/octet-stream');<\/p>\n
} catch (error) {
\n console.error('Failed to load chunk:', error);
\n return null;
\n }
\n }<\/p>\n
\/**
\n * Blob\u8f6cbase64
\n *\/
\n blobToBase64(blob) {
\n return new Promise((resolve, reject) => {
\n const reader = new FileReader();
\n reader.onloadend = () => {
\n const base64 = reader.result.split(',')[1];
\n resolve(base64);
\n };
\n reader.onerror = reject;
\n reader.readAsDataURL(blob);
\n });
\n }<\/p>\n
\/**
\n * base64\u8f6cBlob
\n *\/
\n base64ToBlob(base64, contentType) {
\n const byteCharacters = atob(base64);
\n const byteArrays = [];<\/p>\n
for (let offset = 0; offset < byteCharacters.length; offset += 512) {
\n const slice = byteCharacters.slice(offset, offset + 512);
\n const byteNumbers = new Array(slice.length);<\/p>\n
for (let i = 0; i < slice.length; i++) {
\n byteNumbers[i] = slice.charCodeAt(i);
\n }<\/p>\n
const byteArray = new Uint8Array(byteNumbers);
\n byteArrays.push(byteArray);
\n }<\/p>\n
return new Blob(byteArrays, { type: contentType });
\n }<\/p>\n
\/**
\n * \u8ba1\u7b97\u6574\u4f53\u8fdb\u5ea6
\n *\/
\n calculateOverallProgress(ranges, chunkIndex, chunkProgress) {
\n let totalDownloaded = 0;<\/p>\n
for (let i = 0; i < ranges.length; i++) {
\n const range = ranges[i];
\n if (i < chunkIndex) {
\n \/\/ \u5df2\u5b8c\u6210\u7684\u8303\u56f4
\n totalDownloaded += range.end – range.start + 1;
\n } else if (i === chunkIndex) {
\n \/\/ \u5f53\u524d\u6b63\u5728\u4e0b\u8f7d\u7684\u8303\u56f4
\n const rangeSize = range.end – range.start + 1;
\n totalDownloaded += (rangeSize * chunkProgress) \/ 100;
\n }
\n }<\/p>\n
const totalSize = ranges[ranges.length – 1].end + 1;
\n return (totalDownloaded \/ totalSize) * 100;
\n }<\/p>\n
\/**
\n * \u6e05\u7406\u4e34\u65f6\u6570\u636e
\n *\/
\n async cleanupTempData(url) {
\n const storageKey = `download:${btoa(url)}`;
\n localStorage.removeItem(storageKey);
\n }<\/p>\n
\/**
\n * \u5b8c\u6574\u6587\u4ef6\u4e0b\u8f7d（\u4e0d\u652f\u6301\u8303\u56f4\u8bf7\u6c42\u65f6\u7684\u56de\u9000）
\n *\/
\n async downloadFullFile(url, options) {
\n const { onProgress, onComplete, onError } = options;<\/p>\n
try {
\n const response = await fetch(url);<\/p>\n
if (!response.ok) {
\n throw new Error(`HTTP ${response.status}`);
\n }<\/p>\n
const reader = response.body.getReader();
\n const contentLength = parseInt(response.headers.get('Content-Length'), 10) || 0;<\/p>\n
let receivedLength = 0;
\n const chunks = [];<\/p>\n
while (true) {
\n const { done, value } = await reader.read();<\/p>\n
if (done) {
\n break;
\n }<\/p>\n
chunks.push(value);
\n receivedLength += value.length;<\/p>\n
if (onProgress && contentLength > 0) {
\n onProgress((receivedLength \/ contentLength) * 100);
\n }
\n }<\/p>\n
const blob = new Blob(chunks);<\/p>\n
if (onComplete) {
\n onComplete(blob, {
\n size: contentLength,
\n contentType: response.headers.get('Content-Type')
\n });
\n }<\/p>\n
return blob;<\/p>\n
} catch (error) {
\n if (onError) {
\n onError(error);
\n }
\n throw error;
\n }
\n }
\n}<\/p>\n
\/\/ \u4f7f\u7528\u793a\u4f8b
\nconst downloadManager = new RangeRequestClient({
\n chunkSize: 1024 * 1024 * 5, \/\/ 5MB\u5757
\n parallelDownloads: 4, \/\/ 4\u4e2a\u5e76\u884c\u4e0b\u8f7d
\n maxRetries: 3 \/\/ \u6700\u591a\u91cd\u8bd53\u6b21
\n});<\/p>\n
\/\/ \u5f00\u59cb\u4e0b\u8f7d
\ndocument.getElementById('download-btn').addEventListener('click', async () => {
\n const url = document.getElementById('file-url').value;
\n const progressBar = document.getElementById('progress-bar');
\n const statusText = document.getElementById('status-text');<\/p>\n
try {
\n statusText.textContent = '\u6b63\u5728\u51c6\u5907\u4e0b\u8f7d…';<\/p>\n
await downloadManager.downloadFile(url, {
\n resume: true, \/\/ \u542f\u7528\u65ad\u70b9\u7eed\u4f20<\/p>\n
onProgress: (progress) => {
\n progressBar.style.width = `${progress}%`;
\n progressBar.textContent = `${progress.toFixed(1)}%`;
\n statusText.textContent = `\u4e0b\u8f7d\u4e2d: ${progress.toFixed(1)}%`;
\n },<\/p>\n
onComplete: (blob, fileInfo) => {
\n statusText.textContent = '\u4e0b\u8f7d\u5b8c\u6210!';<\/p>\n
\/\/ \u521b\u5efa\u4e0b\u8f7d\u94fe\u63a5
\n const downloadUrl = URL.createObjectURL(blob);
\n const a = document.createElement('a');
\n a.href = downloadUrl;
\n a.download = getFileNameFromUrl(url);
\n a.click();<\/p>\n
\/\/ \u6e05\u7406
\n URL.revokeObjectURL(downloadUrl);
\n },<\/p>\n
onError: (error) => {
\n console.error('\u4e0b\u8f7d\u5931\u8d25:', error);
\n statusText.textContent = `\u4e0b\u8f7d\u5931\u8d25: ${error.message}`;
\n progressBar.style.backgroundColor = '#dc3545';
\n }
\n });<\/p>\n
} catch (error) {
\n console.error('\u4e0b\u8f7d\u5931\u8d25:', error);
\n statusText.textContent = `\u9519\u8bef: ${error.message}`;
\n }
\n});<\/p>\n
\/\/ \u6682\u505c\u4e0b\u8f7d（\u793a\u4f8b）
\ndocument.getElementById('pause-btn').addEventListener('click', () => {
\n \/\/ \u5728\u5b9e\u9645\u5b9e\u73b0\u4e2d，\u8fd9\u91cc\u9700\u8981\u5b58\u50a8\u5f53\u524d\u72b6\u6001
\n localStorage.setItem('downloadPaused', 'true');
\n alert('\u4e0b\u8f7d\u5df2\u6682\u505c，\u4e0b\u6b21\u53ef\u4ee5\u6062\u590d\u4e0b\u8f7d');
\n});<\/p>\n
function getFileNameFromUrl(url) {
\n return url.split('\/').pop() || 'download.bin';
\n}<\/p>\n
python<\/p>\n
# \u8303\u56f4\u8bf7\u6c42\u6027\u80fd\u4f18\u5316\u5668
\nclass RangeRequestOptimizer:
\n """\u8303\u56f4\u8bf7\u6c42\u6027\u80fd\u4f18\u5316\u5668"""<\/p>\n
def __init__(self):
\n self.cache = {}
\n self.statistics = {
\n 'total_requests': 0,
\n 'range_requests': 0,
\n 'bytes_served': 0,
\n 'cache_hits': 0,
\n 'cache_misses': 0
\n }<\/p>\n
def optimize_response(self, file_path, range_info, use_cache=True):
\n """
\n \u4f18\u5316\u8303\u56f4\u54cd\u5e94<\/p>\n
Args:
\n file_path: \u6587\u4ef6\u8def\u5f84
\n range_info: \u8303\u56f4\u4fe1\u606f
\n use_cache: \u662f\u5426\u4f7f\u7528\u7f13\u5b58<\/p>\n
Returns:
\n (data, from_cache)
\n """
\n self.statistics['total_requests'] += 1
\n self.statistics['range_requests'] += 1<\/p>\n
cache_key = self._generate_cache_key(file_path, range_info)<\/p>\n
# \u68c0\u67e5\u7f13\u5b58
\n if use_cache and cache_key in self.cache:
\n self.statistics['cache_hits'] += 1
\n return self.cache[cache_key], True<\/p>\n
# \u4ece\u6587\u4ef6\u8bfb\u53d6
\n data = self._read_file_range(file_path, range_info)<\/p>\n
# \u7f13\u5b58\u7ed3\u679c（\u5982\u679c\u503c\u5f97\u7f13\u5b58）
\n if self._should_cache(range_info):
\n self.cache[cache_key] = data
\n self.statistics['cache_misses'] += 1<\/p>\n
return data, False<\/p>\n
def _generate_cache_key(self, file_path, range_info):
\n """\u751f\u6210\u7f13\u5b58\u952e"""
\n import hashlib
\n import os<\/p>\n
stat = os.stat(file_path)
\n key_content = f"{file_path}:{stat.st_mtime}:{range_info['start']}:{range_info['end']}"
\n return hashlib.md5(key_content.encode()).hexdigest()<\/p>\n
def _read_file_range(self, file_path, range_info):
\n """\u4ece\u6587\u4ef6\u8bfb\u53d6\u8303\u56f4"""
\n start = range_info['start']
\n end = range_info['end']
\n length = end – start + 1<\/p>\n
with open(file_path, 'rb') as f:
\n f.seek(start)
\n return f.read(length)<\/p>\n
def _should_cache(self, range_info):
\n """\u5224\u65ad\u662f\u5426\u5e94\u8be5\u7f13\u5b58"""
\n # \u57fa\u4e8e\u8303\u56f4\u5927\u5c0f\u51b3\u5b9a\u662f\u5426\u7f13\u5b58
\n range_size = range_info['end'] – range_info['start'] + 1<\/p>\n
# \u5c0f\u8303\u56f4\u8bf7\u6c42\u66f4\u53ef\u80fd\u88ab\u91cd\u590d\u8bf7\u6c42（\u4f8b\u5982\u89c6\u9891\u6d41\u7684\u5f00\u59cb\u90e8\u5206）
\n if range_size <= 1024 * 1024: # 1MB\u4ee5\u4e0b
\n return True<\/p>\n
# \u7279\u5b9a\u6a21\u5f0f\u7684\u8303\u56f4\u8bf7\u6c42（\u4f8b\u5982\u89c6\u9891\u7684\u56fa\u5b9a\u65f6\u95f4\u70b9）
\n if range_info['start'] % (1024 * 1024) == 0: # \u5bf9\u9f50\u52301MB\u8fb9\u754c
\n return True<\/p>\n
return False<\/p>\n
def preload_cache(self, file_path, common_ranges):
\n """
\n \u9884\u52a0\u8f7d\u5e38\u7528\u8303\u56f4\u5230\u7f13\u5b58<\/p>\n
Args:
\n file_path: \u6587\u4ef6\u8def\u5f84
\n common_ranges: \u5e38\u7528\u8303\u56f4\u5217\u8868
\n """
\n for range_info in common_ranges:
\n cache_key = self._generate_cache_key(file_path, range_info)
\n if cache_key not in self.cache:
\n data = self._read_file_range(file_path, range_info)
\n self.cache[cache_key] = data<\/p>\n
def cleanup_cache(self, max_size_mb=100):
\n """\u6e05\u7406\u7f13\u5b58，\u4fdd\u6301\u6700\u5927\u5927\u5c0f"""
\n import sys<\/p>\n
cache_size = sum(sys.getsizeof(v) for v in self.cache.values())
\n max_size = max_size_mb * 1024 * 1024<\/p>\n
if cache_size > max_size:
\n # \u4f7f\u7528LRU\u7b56\u7565\u6e05\u7406\u7f13\u5b58
\n # \u8fd9\u91cc\u7b80\u5316\u5b9e\u73b0：\u76f4\u63a5\u6e05\u7406\u4e00\u534a\u7f13\u5b58
\n keys = list(self.cache.keys())
\n for key in keys[:len(keys)\/\/2]:
\n del self.cache[key]<\/p>\n
def get_optimization_suggestions(self, request_patterns):
\n """
\n \u57fa\u4e8e\u8bf7\u6c42\u6a21\u5f0f\u63d0\u4f9b\u4f18\u5316\u5efa\u8bae<\/p>\n
Args:
\n request_patterns: \u8bf7\u6c42\u6a21\u5f0f\u5217\u8868<\/p>\n
Returns:
\n \u4f18\u5316\u5efa\u8bae\u5b57\u5178
\n """
\n suggestions = []<\/p>\n
# \u5206\u6790\u8bf7\u6c42\u6a21\u5f0f
\n sequential_requests = self._analyze_sequential_requests(request_patterns)
\n repeated_ranges = self._find_repeated_ranges(request_patterns)<\/p>\n
# \u5efa\u8bae1：\u9884\u52a0\u8f7d\u5e38\u7528\u8303\u56f4
\n if repeated_ranges:
\n suggestions.append({
\n 'type': 'preload',
\n 'priority': 'high',
\n 'message': f'\u53d1\u73b0{len(repeated_ranges)}\u4e2a\u91cd\u590d\u8bf7\u6c42\u7684\u8303\u56f4，\u5efa\u8bae\u9884\u52a0\u8f7d\u5230\u7f13\u5b58',
\n 'ranges': repeated_ranges[:5] # \u524d5\u4e2a\u6700\u5e38\u8bf7\u6c42\u7684\u8303\u56f4
\n })<\/p>\n
# \u5efa\u8bae2：\u8c03\u6574\u5757\u5927\u5c0f
\n avg_range_size = self._calculate_average_range_size(request_patterns)
\n if avg_range_size > 1024 * 1024 * 10: # 10MB\u4ee5\u4e0a
\n suggestions.append({
\n 'type': 'chunk_size',
\n 'priority': 'medium',
\n 'message': f'\u5e73\u5747\u8bf7\u6c42\u8303\u56f4\u8f83\u5927({avg_range_size\/1024\/1024:.1f}MB)，\u5efa\u8bae\u589e\u52a0\u5757\u5927\u5c0f',
\n 'recommended_size': min(avg_range_size * 2, 1024 * 1024 * 100) # \u6700\u5927100MB
\n })<\/p>\n
# \u5efa\u8bae3：\u987a\u5e8f\u8bfb\u53d6\u4f18\u5316
\n if sequential_requests['is_sequential']:
\n suggestions.append({
\n 'type': 'sequential_read',
\n 'priority': 'low',
\n 'message': '\u68c0\u6d4b\u5230\u987a\u5e8f\u8bfb\u53d6\u6a21\u5f0f，\u53ef\u4ee5\u542f\u7528\u9884\u8bfb\u4f18\u5316',
\n 'read_ahead_size': sequential_requests['avg_gap'] * 2
\n })<\/p>\n
return suggestions<\/p>\n
def _analyze_sequential_requests(self, patterns):
\n """\u5206\u6790\u987a\u5e8f\u8bf7\u6c42\u6a21\u5f0f"""
\n if len(patterns) < 3:
\n return {'is_sequential': False}<\/p>\n
# \u68c0\u67e5\u662f\u5426\u5927\u81f4\u8fde\u7eed
\n gaps = []
\n for i in range(1, len(patterns)):
\n prev_end = patterns[i-1]['end']
\n curr_start = patterns[i]['start']<\/p>\n
if curr_start >= prev_end:
\n gaps.append(curr_start – prev_end)<\/p>\n
if len(gaps) == 0:
\n return {'is_sequential': False}<\/p>\n
avg_gap = sum(gaps) \/ len(gaps)<\/p>\n
# \u5982\u679c\u5e73\u5747\u95f4\u9694\u5c0f\u4e8e\u5757\u5927\u5c0f\u768410%，\u8ba4\u4e3a\u662f\u987a\u5e8f\u8bfb\u53d6
\n avg_range_size = self._calculate_average_range_size(patterns)<\/p>\n
return {
\n 'is_sequential': avg_gap < avg_range_size * 0.1,
\n 'avg_gap': avg_gap,
\n 'gap_count': len(gaps)
\n }<\/p>\n
def _find_repeated_ranges(self, patterns):
\n """\u67e5\u627e\u91cd\u590d\u8bf7\u6c42\u7684\u8303\u56f4"""
\n from collections import Counter<\/p>\n
range_strings = [f"{p['start']}-{p['end']}" for p in patterns]
\n counter = Counter(range_strings)<\/p>\n
# \u8fd4\u56de\u8bf7\u6c42\u6b21\u6570\u5927\u4e8e1\u7684\u8303\u56f4
\n repeated = []
\n for range_str, count in counter.items():
\n if count > 1:
\n start, end = map(int, range_str.split('-'))
\n repeated.append({
\n 'start': start,
\n 'end': end,
\n 'count': count
\n })<\/p>\n
# \u6309\u8bf7\u6c42\u6b21\u6570\u6392\u5e8f
\n repeated.sort(key=lambda x: x['count'], reverse=True)
\n return repeated<\/p>\n
def _calculate_average_range_size(self, patterns):
\n """\u8ba1\u7b97\u5e73\u5747\u8303\u56f4\u5927\u5c0f"""
\n if not patterns:
\n return 0<\/p>\n
total_size = sum(p['end'] – p['start'] + 1 for p in patterns)
\n return total_size \/ len(patterns)<\/p>\n
# \u5b8c\u6574\u7684HTTP\u8303\u56f4\u8bf7\u6c42\u670d\u52a1\u5668\u4f18\u5316\u7248
\nclass OptimizedRangeServer:
\n """\u4f18\u5316\u7684\u8303\u56f4\u8bf7\u6c42\u670d\u52a1\u5668"""<\/p>\n
def __init__(self, base_dir, cache_size_mb=100):
\n self.base_dir = base_dir
\n self.optimizer = RangeRequestOptimizer()
\n self.cache_size_mb = cache_size_mb<\/p>\n
# \u9884\u5b9a\u4e49\u5e38\u7528\u8303\u56f4（\u4f8b\u5982\u89c6\u9891\u6587\u4ef6\u7684\u5f00\u59cb\u90e8\u5206）
\n self.common_ranges = [
\n {'start': 0, 'end': 1024 * 1024 – 1}, # \u7b2c\u4e00\u4e2a1MB
\n {'start': 0, 'end': 1024 * 10 – 1}, # \u524d10KB（\u6587\u4ef6\u5934）
\n {'start': 0, 'end': 1024 * 512 – 1}, # \u524d512KB
\n ]<\/p>\n
def serve_request(self, file_path, range_header):
\n """
\n \u63d0\u4f9b\u8303\u56f4\u8bf7\u6c42\u670d\u52a1<\/p>\n
Args:
\n file_path: \u76f8\u5bf9\u6587\u4ef6\u8def\u5f84
\n range_header: Range\u5934\u90e8\u503c<\/p>\n
Returns:
\n HTTP\u54cd\u5e94
\n """
\n full_path = os.path.join(self.base_dir, file_path)<\/p>\n
if not os.path.exists(full_path):
\n return self._error_response(404, 'File not found')<\/p>\n
file_size = os.path.getsize(full_path)<\/p>\n
# \u89e3\u6790Range\u5934\u90e8
\n parser = RangeHeaderParser()
\n parse_result = parser.parse(range_header, file_size)<\/p>\n
if not parse_result['valid']:
\n return self._range_not_satisfiable_response(file_size)<\/p>\n
ranges = parse_result['ranges']<\/p>\n
# \u5355\u4e2a\u8303\u56f4
\n if len(ranges) == 1:
\n return self._serve_single_range(full_path, ranges[0], file_size)<\/p>\n
# \u591a\u4e2a\u8303\u56f4
\n else:
\n return self._serve_multipart_ranges(full_path, ranges, file_size)<\/p>\n
def _serve_single_range(self, file_path, range_info, file_size):
\n """\u63d0\u4f9b\u5355\u4e2a\u8303\u56f4"""
\n # \u4f7f\u7528\u4f18\u5316\u5668\u83b7\u53d6\u6570\u636e
\n data, from_cache = self.optimizer.optimize_response(
\n file_path, range_info, use_cache=True
\n )<\/p>\n
headers = {
\n 'Content-Range': f'bytes {range_info["start"]}-{range_info["end"]}\/{file_size}',
\n 'Content-Length': str(len(data)),
\n 'Content-Type': self._get_content_type(file_path),
\n 'Accept-Ranges': 'bytes',
\n 'Cache-Control': 'public, max-age=31536000',
\n 'X-Cache': 'HIT' if from_cache else 'MISS',
\n 'X-Optimized': 'true'
\n }<\/p>\n
return Response(data, status=206, headers=headers)<\/p>\n
def _serve_multipart_ranges(self, file_path, ranges, file_size):
\n """\u63d0\u4f9b\u591a\u4e2a\u8303\u56f4"""
\n boundary = f"boundary_{hash(str(ranges))}_{int(time.time())}"
\n content_type = f"multipart\/byteranges; boundary={boundary}"<\/p>\n
# \u751f\u6210\u591a\u90e8\u5206\u54cd\u5e94
\n parts = []
\n total_length = 0<\/p>\n
for range_info in ranges:
\n # \u83b7\u53d6\u8303\u56f4\u6570\u636e
\n data, from_cache = self.optimizer.optimize_response(
\n file_path, range_info, use_cache=True
\n )<\/p>\n
# \u6784\u5efa\u90e8\u5206
\n part = self._build_multipart_part(
\n boundary, range_info, file_size, data, from_cache
\n )
\n parts.append(part)
\n total_length += len(part)<\/p>\n
# \u6dfb\u52a0\u7ed3\u675f\u8fb9\u754c
\n end_boundary = f"\\\\r\\\\n–{boundary}–\\\\r\\\\n"
\n parts.append(end_boundary.encode())
\n total_length += len(end_boundary)<\/p>\n
headers = {
\n 'Content-Type': content_type,
\n 'Content-Length': str(total_length),
\n 'Accept-Ranges': 'bytes',
\n 'Cache-Control': 'no-store',
\n 'X-Optimized': 'true'
\n }<\/p>\n
# \u7ec4\u5408\u6240\u6709\u90e8\u5206
\n def generate():
\n for part in parts:
\n if isinstance(part, bytes):
\n yield part
\n else:
\n yield part<\/p>\n
return Response(generate(), status=206, headers=headers)<\/p>\n
def _build_multipart_part(self, boundary, range_info, file_size, data, from_cache):
\n """\u6784\u5efa\u591a\u90e8\u5206\u54cd\u5e94\u7684\u5355\u4e2a\u90e8\u5206"""
\n part_headers = [
\n f'–{boundary}',
\n f'Content-Range: bytes {range_info["start"]}-{range_info["end"]}\/{file_size}',
\n f'Content-Type: {self._get_content_type(None)}',
\n f'X-Cache: {"HIT" if from_cache else "MISS"}',
\n ''
\n ]<\/p>\n
header_bytes = '\\\\r\\\\n'.join(part_headers).encode()
\n return header_bytes + data<\/p>\n
def _get_content_type(self, file_path):
\n """\u83b7\u53d6\u5185\u5bb9\u7c7b\u578b"""
\n if not file_path:
\n return 'application\/octet-stream'<\/p>\n
mime_types = {
\n '.mp4': 'video\/mp4',
\n '.avi': 'video\/x-msvideo',
\n '.mkv': 'video\/x-matroska',
\n '.mov': 'video\/quicktime',
\n '.mp3': 'audio\/mpeg',
\n '.jpg': 'image\/jpeg',
\n '.png': 'image\/png',
\n '.pdf': 'application\/pdf',
\n '.zip': 'application\/zip'
\n }<\/p>\n
ext = os.path.splitext(file_path)[1].lower()
\n return mime_types.get(ext, 'application\/octet-stream')<\/p>\n
def _error_response(self, status, message):
\n """\u9519\u8bef\u54cd\u5e94"""
\n return Response(message, status=status)<\/p>\n
def _range_not_satisfiable_response(self, file_size):
\n """416\u54cd\u5e94"""
\n return Response(
\n 'Requested range not satisfiable',
\n status=416,
\n headers={
\n 'Content-Range': f'bytes *\/{file_size}',
\n 'Content-Type': 'text\/plain'
\n }
\n )<\/p>\n
def preload_common_ranges(self, file_path):
\n """\u9884\u52a0\u8f7d\u5e38\u7528\u8303\u56f4"""
\n full_path = os.path.join(self.base_dir, file_path)
\n if os.path.exists(full_path):
\n self.optimizer.preload_cache(full_path, self.common_ranges)<\/p>\n
def cleanup(self):
\n """\u6e05\u7406\u8d44\u6e90"""
\n self.optimizer.cleanup_cache(self.cache_size_mb)<\/p>\n
def get_stats(self):
\n """\u83b7\u53d6\u7edf\u8ba1\u4fe1\u606f"""
\n return self.optimizer.statistics<\/p>\n
# \u4f7f\u7528\u793a\u4f8b
\nif __name__ == '__main__':
\n import argparse<\/p>\n
parser = argparse.ArgumentParser(description='Optimized Range Request Server')
\n parser.add_argument('–port', type=int, default=8080, help='Port to listen on')
\n parser.add_argument('–dir', default='.\/files', help='Directory to serve files from')
\n parser.add_argument('–cache', type=int, default=100, help='Cache size in MB')<\/p>\n
args = parser.parse_args()<\/p>\n
# \u521b\u5efa\u670d\u52a1\u5668
\n server = OptimizedRangeServer(args.dir, args.cache)<\/p>\n
# \u521b\u5efaFlask\u5e94\u7528
\n app = Flask(__name__)<\/p>\n
@app.route('\/files\/<path:filename>')
\n def serve_file(filename):
\n """\u63d0\u4f9b\u6587\u4ef6\u670d\u52a1"""
\n range_header = request.headers.get('Range')<\/p>\n
if range_header:
\n return server.serve_request(filename, range_header)
\n else:
\n # \u5b8c\u6574\u6587\u4ef6\u8bf7\u6c42
\n full_path = os.path.join(server.base_dir, filename)
\n if os.path.exists(full_path):
\n return send_file(full_path)
\n else:
\n return jsonify({'error': 'File not found'}), 404<\/p>\n
@app.route('\/preload\/<path:filename>')
\n def preload_file(filename):
\n """\u9884\u52a0\u8f7d\u6587\u4ef6\u5e38\u7528\u8303\u56f4"""
\n try:
\n server.preload_common_ranges(filename)
\n return jsonify({
\n 'success': True,
\n 'message': f'Preloaded common ranges for {filename}'
\n })
\n except Exception as e:
\n return jsonify({
\n 'success': False,
\n 'error': str(e)
\n }), 500<\/p>\n
@app.route('\/stats')
\n def get_stats():
\n """\u83b7\u53d6\u670d\u52a1\u5668\u7edf\u8ba1"""
\n return jsonify(server.get_stats())<\/p>\n
@app.before_request
\n def log_request():
\n """\u8bb0\u5f55\u8bf7\u6c42\u65e5\u5fd7"""
\n app.logger.info(f"{request.method} {request.path} – Range: {request.headers.get('Range')}")<\/p>\n
# \u5b9a\u671f\u6e05\u7406\u7f13\u5b58
\n import atexit
\n atexit.register(server.cleanup)<\/p>\n
# \u542f\u52a8\u670d\u52a1\u5668
\n app.run(host='0.0.0.0', port=args.port, threaded=True)<\/p>\n
yaml<\/p>\n
# 206 Partial Content\u6700\u4f73\u5b9e\u8df5\u6e05\u5355
\nbest_practices_206:<\/p>\n
# \u670d\u52a1\u5668\u5b9e\u73b0
\n server_implementation:
\n – \u59cb\u7ec8\u8bbe\u7f6eAccept-Ranges: bytes\u5934\u90e8
\n – \u6b63\u786e\u89e3\u6790\u548c\u5904\u7406Range\u8bf7\u6c42\u5934\u90e8
\n – \u5bf9\u4e8e\u65e0\u6548\u8303\u56f4\u8fd4\u56de416 Range Not Satisfiable
\n – \u652f\u6301\u5355\u8303\u56f4\u548c\u591a\u8303\u56f4\u8bf7\u6c42
\n – \u4e3a\u591a\u8303\u56f4\u8bf7\u6c42\u751f\u6210\u6b63\u786e\u7684multipart\/byteranges\u54cd\u5e94<\/p>\n
# \u6027\u80fd\u4f18\u5316
\n performance_optimization:
\n – \u4e3a\u5c0f\u8303\u56f4\u8bf7\u6c42\u5b9e\u73b0\u7f13\u5b58
\n – \u9884\u52a0\u8f7d\u5e38\u7528\u8303\u56f4（\u5982\u6587\u4ef6\u5f00\u5934）
\n – \u4f7f\u7528\u5408\u9002\u7684\u5757\u5927\u5c0f（\u901a\u5e3864KB-1MB）
\n – \u652f\u6301\u5e76\u884c\u8303\u56f4\u8bf7\u6c42
\n – \u5b9e\u73b0\u6761\u4ef6\u8bf7\u6c42（If-Range, If-Match\u7b49）<\/p>\n
# \u5b89\u5168\u8003\u8651
\n security:
\n – \u9a8c\u8bc1\u8303\u56f4\u8bf7\u6c42\u7684\u5408\u6cd5\u6027
\n – \u9650\u5236\u6700\u5927\u8303\u56f4\u5927\u5c0f\u548c\u6570\u91cf
\n – \u9632\u6b62\u8d44\u6e90\u8017\u5c3d\u653b\u51fb
\n – \u8bb0\u5f55\u5f02\u5e38\u8303\u56f4\u8bf7\u6c42\u6a21\u5f0f
\n – \u5b9e\u65bd\u901f\u7387\u9650\u5236<\/p>\n
# \u5ba2\u6237\u7aef\u5904\u7406
\n client_handling:
\n – \u68c0\u67e5Accept-Ranges\u5934\u90e8\u4ee5\u4e86\u89e3\u670d\u52a1\u5668\u652f\u6301
\n – \u6b63\u786e\u5904\u7406206\u548c416\u72b6\u6001\u7801
\n – \u5b9e\u73b0\u65ad\u70b9\u7eed\u4f20\u529f\u80fd
\n – \u5bf9\u5927\u578b\u6587\u4ef6\u4f7f\u7528\u5e76\u884c\u4e0b\u8f7d
\n – \u5904\u7406\u7f51\u7edc\u9519\u8bef\u548c\u91cd\u8bd5<\/p>\n
# \u7f13\u5b58\u7b56\u7565
\n caching:
\n – 206\u54cd\u5e94\u901a\u5e38\u53ef\u7f13\u5b58
\n – \u8bbe\u7f6e\u9002\u5f53\u7684Cache-Control\u5934\u90e8
\n – \u5bf9\u4e8e\u89c6\u9891\u6d41\u4f7f\u7528public\u7f13\u5b58
\n – \u8003\u8651\u8303\u56f4\u7279\u5b9a\u7684\u7f13\u5b58\u7b56\u7565<\/p>\n
# \u7279\u6b8a\u60c5\u51b5\u5904\u7406
\n special_cases:
\n – \u5904\u7406\u540e\u7f00\u8303\u56f4（\u5982bytes=-100）
\n – \u5904\u7406\u5f00\u533a\u95f4\u8303\u56f4（\u5982bytes=100-）
\n – \u5904\u7406\u91cd\u53e0\u8303\u56f4\u7684\u8bf7\u6c42
\n – \u5904\u7406\u8d85\u51fa\u6587\u4ef6\u5927\u5c0f\u7684\u8303\u56f4<\/p>\n
# \u76d1\u63a7\u548c\u65e5\u5fd7
\n monitoring:
\n – \u8bb0\u5f55\u8303\u56f4\u8bf7\u6c42\u7edf\u8ba1
\n – \u76d1\u63a7\u8303\u56f4\u8bf7\u6c42\u7684\u6210\u529f\u7387
\n – \u8ddf\u8e2a\u5b57\u8282\u670d\u52a1\u91cf
\n – \u68c0\u6d4b\u5f02\u5e38\u8bf7\u6c42\u6a21\u5f0f<\/p>\n
# \u517c\u5bb9\u6027\u8003\u8651
\n compatibility:
\n – \u652f\u6301HTTP\/1.1 Range\u89c4\u8303
\n – \u8003\u8651\u4e0d\u652f\u6301\u8303\u56f4\u8bf7\u6c42\u7684\u5ba2\u6237\u7aef
\n – \u63d0\u4f9b\u56de\u9000\u673a\u5236
\n – \u6d4b\u8bd5\u5404\u79cdRange\u683c\u5f0f<\/p>\n
\u901a\u8fc7\u672c\u7ae0\u7684\u8be6\u7ec6\u89e3\u6790，\u6211\u4eec\u6df1\u5165\u4e86\u89e3\u4e86206 Partial Content\u72b6\u6001\u7801\u7684\u5b9e\u73b0\u7ec6\u8282\u3001\u4f18\u5316\u7b56\u7565\u548c\u6700\u4f73\u5b9e\u8df5\u3002206\u72b6\u6001\u7801\u5728\u73b0\u4ee3Web\u5e94\u7528\u4e2d\u975e\u5e38\u91cd\u8981，\u7279\u522b\u662f\u5728\u5927\u6587\u4ef6\u4f20\u8f93\u3001\u6d41\u5a92\u4f53\u548c\u65ad\u70b9\u7eed\u4f20\u7b49\u573a\u666f\u4e2d\u3002<\/p>\n
\u6b63\u786e\u5b9e\u73b0206\u54cd\u5e94\u53ef\u4ee5\u663e\u8457\u63d0\u9ad8\u6570\u636e\u4f20\u8f93\u6548\u7387，\u6539\u5584\u7528\u6237\u4f53\u9a8c，\u540c\u65f6\u51cf\u5c11\u670d\u52a1\u5668\u8d1f\u8f7d\u3002<\/p>\n
\u6839\u636eRFC 7231\u7b2c6.3.4\u8282，203 Non-Authoritative Information\u72b6\u6001\u7801\u7684\u5b9a\u4e49\u5982\u4e0b：<\/p>\n
203 (Non-Authoritative Information)\u72b6\u6001\u7801\u8868\u793a\u8bf7\u6c42\u5df2\u6210\u529f，\u4f46\u5305\u542b\u7684\u5b9e\u4f53\u5934\u90e8（entity-header）\u4fe1\u606f\u5e76\u975e\u6765\u81ea\u539f\u59cb\u670d\u52a1\u5668，\u800c\u662f\u6765\u81ea\u672c\u5730\u6216\u7b2c\u4e09\u65b9\u526f\u672c\u3002\u8fd9\u53ef\u80fd\u5305\u62ec\u5bf9\u8868\u793a\u5f62\u5f0f\u7684\u6ce8\u89e3（\u5982\u6dfb\u52a0"via"\u5934\u90e8），\u8fd9\u4e9b\u6ce8\u89e3\u7531\u4e2d\u95f4\u8282\u70b9（\u5982\u4ee3\u7406\u670d\u52a1\u5668）\u5e94\u7528\u3002<\/p>\n
\u4fe1\u606f\u6e90\u975e\u6743\u5a01：\u54cd\u5e94\u5934\u90e8\u4fe1\u606f\u4e0d\u662f\u6765\u81ea\u539f\u59cb\u670d\u52a1\u5668<\/p>\n<\/li>\n
\u5b9e\u4f53\u4e3b\u4f53\u53ef\u9760：\u54cd\u5e94\u4f53\u5185\u5bb9\u4ecd\u88ab\u8ba4\u4e3a\u6709\u6548<\/p>\n<\/li>\n
\u4e2d\u95f4\u8282\u70b9\u5904\u7406：\u7531\u4ee3\u7406\u3001\u7f51\u5173\u6216\u7f13\u5b58\u670d\u52a1\u5668\u751f\u6210<\/p>\n<\/li>\n
\u53ef\u9009\u4f7f\u7528：\u5728HTTP\/1.1\u4e2d\u4e0d\u5e38\u7528，\u901a\u5e38\u7531\u4ee3\u7406\u5904\u7406<\/p>\n<\/li>\n
python<\/p>\n
# 203 Non-Authoritative Information\u670d\u52a1\u5668\u5b9e\u73b0
\nfrom flask import Flask, jsonify, Response
\nfrom datetime import datetime
\nimport hashlib<\/p>\n
app = Flask(__name__)<\/p>\n
class NonAuthoritativeResponse:
\n """203\u54cd\u5e94\u751f\u6210\u5668"""<\/p>\n
@staticmethod
\n def create_response(data, original_headers=None, transformed_by=None):
\n """
\n \u521b\u5efa203\u54cd\u5e94<\/p>\n
Args:
\n data: \u54cd\u5e94\u6570\u636e
\n original_headers: \u539f\u59cb\u5934\u90e8（\u5982\u679c\u6709）
\n transformed_by: \u8f6c\u6362\u670d\u52a1\u7684\u6807\u8bc6<\/p>\n
Returns:
\n Flask Response\u5bf9\u8c61
\n """<\/p>\n
# \u6784\u5efa\u54cd\u5e94
\n response = jsonify(data)
\n response.status_code = 203<\/p>\n
# \u8bbe\u7f6e\u6807\u51c6\u5934\u90e8
\n response.headers['Date'] = datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S GMT')
\n response.headers['Server'] = 'ProxyServer\/1.0'<\/p>\n
# \u6dfb\u52a0Warning\u5934\u90e8（RFC 7234\u5b9a\u4e49）
\n response.headers['Warning'] = '214 Transformation applied'<\/p>\n
# \u6dfb\u52a0Via\u5934\u90e8（\u5982\u679c\u6709\u4e2d\u95f4\u4ee3\u7406）
\n if transformed_by:
\n response.headers['Via'] = f'1.1 {transformed_by}'<\/p>\n
# \u6dfb\u52a0X-\u5934\u90e8\u8868\u793a\u975e\u6743\u5a01\u4fe1\u606f
\n response.headers['X-Information-Source'] = 'Non-authoritative'
\n response.headers['X-Transformed-By'] = transformed_by or 'proxy-server'<\/p>\n
# \u4fdd\u7559\u539f\u59cb\u5934\u90e8\u4fe1\u606f（\u5982\u679c\u63d0\u4f9b）
\n if original_headers:
\n response.headers['X-Original-Headers'] = str(original_headers)<\/p>\n
# \u6dfb\u52a0\u7f13\u5b58\u63a7\u5236
\n response.headers['Cache-Control'] = 'public, max-age=300, s-maxage=600'<\/p>\n
# \u6dfb\u52a0\u5b9e\u4f53\u6807\u7b7e
\n etag = NonAuthoritativeResponse._generate_etag(data)
\n response.headers['ETag'] = etag<\/p>\n
return response<\/p>\n
@staticmethod
\n def _generate_etag(data):
\n """\u751f\u6210ETag"""
\n content = str(data).encode('utf-8')
\n return f'"{hashlib.md5(content).hexdigest()}"'<\/p>\n
# \u4ee3\u7406\u670d\u52a1\u5668\u7aef\u70b9
\n@app.route('\/proxy\/api\/<path:endpoint>')
\ndef proxy_endpoint(endpoint):
\n """
\n \u4ee3\u7406\u7aef\u70b9\u793a\u4f8b：\u4ece\u4e0a\u6e38\u83b7\u53d6\u6570\u636e\u5e76\u6dfb\u52a0\u975e\u6743\u5a01\u4fe1\u606f<\/p>\n
\u6a21\u62df\u573a\u666f：
\n 1. \u4ece\u539f\u59cb\u670d\u52a1\u5668\u83b7\u53d6\u6570\u636e
\n 2. \u4fee\u6539\u6216\u6dfb\u52a0\u5934\u90e8\u4fe1\u606f
\n 3. \u8fd4\u56de203\u54cd\u5e94
\n """<\/p>\n
# \u6a21\u62df\u4ece\u4e0a\u6e38\u670d\u52a1\u5668\u83b7\u53d6\u6570\u636e
\n upstream_data = {
\n 'id': 123,
\n 'name': 'Example Resource',
\n 'timestamp': datetime.utcnow().isoformat(),
\n 'source': 'upstream-server'
\n }<\/p>\n
# \u6a21\u62df\u6dfb\u52a0\u7684\u8f6c\u6362\u6216\u6ce8\u89e3
\n upstream_data['annotations'] = {
\n 'cached': True,
\n 'cache_ttl': 300,
\n 'proxy_version': '1.2.3',
\n 'processed_at': datetime.utcnow().isoformat()
\n }<\/p>\n
# \u6a21\u62df\u539f\u59cb\u5934\u90e8
\n original_headers = {
\n 'Server': 'UpstreamServer\/1.0',
\n 'X-Upstream-ID': 'server-abc123'
\n }<\/p>\n
# \u521b\u5efa203\u54cd\u5e94
\n return NonAuthoritativeResponse.create_response(
\n data=upstream_data,
\n original_headers=original_headers,
\n transformed_by='edge-proxy.example.com'
\n )<\/p>\n
# \u5185\u5bb9\u8f6c\u6362\u670d\u52a1\u793a\u4f8b
\nclass ContentTransformer:
\n """\u5185\u5bb9\u8f6c\u6362\u670d\u52a1，\u8fd4\u56de203\u54cd\u5e94"""<\/p>\n
def __init__(self):
\n self.transformations = {
\n 'compress': self._compress_content,
\n 'filter': self._filter_content,
\n 'annotate': self._annotate_content,
\n 'translate': self._translate_content
\n }<\/p>\n
def transform_response(self, original_response, transformation_type, **kwargs):
\n """
\n \u8f6c\u6362\u54cd\u5e94\u5e76\u8fd4\u56de203<\/p>\n
Args:
\n original_response: \u539f\u59cb\u54cd\u5e94\u6570\u636e
\n transformation_type: \u8f6c\u6362\u7c7b\u578b
\n **kwargs: \u8f6c\u6362\u53c2\u6570<\/p>\n
Returns:
\n 203\u54cd\u5e94
\n """<\/p>\n
# \u5e94\u7528\u8f6c\u6362
\n transformer = self.transformations.get(transformation_type)
\n if not transformer:
\n return original_response<\/p>\n
transformed_data = transformer(original_response, **kwargs)<\/p>\n
# \u521b\u5efa203\u54cd\u5e94
\n response_data = {
\n 'data': transformed_data,
\n 'metadata': {
\n 'original_size': len(str(original_response)),
\n 'transformed_size': len(str(transformed_data)),
\n 'transformation': transformation_type,
\n 'applied_at': datetime.utcnow().isoformat(),
\n 'reduction_percentage': self._calculate_reduction(
\n original_response, transformed_data
\n )
\n },
\n 'original_data': original_response if kwargs.get('include_original') else None
\n }<\/p>\n
return NonAuthoritativeResponse.create_response(
\n data=response_data,
\n transformed_by=f'content-transformer-{transformation_type}'
\n )<\/p>\n
def _compress_content(self, data, **kwargs):
\n """\u538b\u7f29\u5185\u5bb9（\u6a21\u62df）"""
\n # \u5b9e\u9645\u4e2d\u4f1a\u4f7f\u7528gzip\u6216\u5176\u4ed6\u538b\u7f29
\n import json
\n return json.dumps(data, separators=(',', ':')) # \u6700\u5c0f\u5316JSON<\/p>\n
def _filter_content(self, data, fields=None, **kwargs):
\n """\u8fc7\u6ee4\u5185\u5bb9\u5b57\u6bb5"""
\n if not fields or not isinstance(data, dict):
\n return data<\/p>\n
filtered = {}
\n for field in fields:
\n if field in data:
\n filtered[field] = data[field]<\/p>\n
return filtered<\/p>\n
def _annotate_content(self, data, **kwargs):
\n """\u6dfb\u52a0\u6ce8\u91ca"""
\n annotated = dict(data)
\n annotated['_annotations'] = {
\n 'processed': True,
\n 'processor': 'annotation-service',
\n 'version': '1.0',
\n 'timestamp': datetime.utcnow().isoformat()
\n }
\n return annotated<\/p>\n
def _translate_content(self, data, target_lang='en', **kwargs):
\n """\u7ffb\u8bd1\u5185\u5bb9（\u6a21\u62df）"""
\n # \u5b9e\u9645\u4e2d\u4f1a\u8c03\u7528\u7ffb\u8bd1\u670d\u52a1
\n translated = dict(data)
\n if 'name' in translated:
\n translated['name'] = f"[{target_lang}] {translated['name']}"
\n return translated<\/p>\n
def _calculate_reduction(self, original, transformed):
\n """\u8ba1\u7b97\u5927\u5c0f\u51cf\u5c11\u767e\u5206\u6bd4"""
\n orig_size = len(str(original))
\n trans_size = len(str(transformed))<\/p>\n
if orig_size == 0:
\n return 0<\/p>\n
reduction = (orig_size – trans_size) \/ orig_size * 100
\n return round(reduction, 2)<\/p>\n
# \u4f7f\u7528\u793a\u4f8b
\ntransformer = ContentTransformer()<\/p>\n
@app.route('\/api\/transform\/<transformation>')
\ndef transform_content(transformation):
\n """\u5185\u5bb9\u8f6c\u6362\u7aef\u70b9"""<\/p>\n
# \u539f\u59cb\u6570\u636e
\n original_data = {
\n 'id': 456,
\n 'name': '\u793a\u4f8b\u8d44\u6e90',
\n 'description': '\u8fd9\u662f\u4e00\u4e2a\u9700\u8981\u8f6c\u6362\u7684\u793a\u4f8b\u8d44\u6e90',
\n 'content': '\u8fd9\u91cc\u662f\u8be6\u7ec6\u7684\u5185\u5bb9\u4fe1\u606f，\u53ef\u80fd\u4f1a\u5f88\u957f…',
\n 'metadata': {
\n 'created': '2023-01-01',
\n 'updated': '2023-01-23',
\n 'tags': ['example', 'test', 'data']
\n }
\n }<\/p>\n
# \u5e94\u7528\u8f6c\u6362
\n transformed_response = transformer.transform_response(
\n original_data,
\n transformation,
\n include_original=False
\n )<\/p>\n
return transformed_response<\/p>\n
# \u7f13\u5b58\u4ee3\u7406\u5b9e\u73b0
\nclass CachingProxy:
\n """\u7f13\u5b58\u4ee3\u7406\u8fd4\u56de203\u54cd\u5e94"""<\/p>\n
def __init__(self, cache_duration=300):
\n self.cache = {}
\n self.cache_duration = cache_duration<\/p>\n
def get_cached_response(self, request_url, force_refresh=False):
\n """
\n \u83b7\u53d6\u7f13\u5b58\u54cd\u5e94<\/p>\n
Args:
\n request_url: \u8bf7\u6c42URL
\n force_refresh: \u662f\u5426\u5f3a\u5236\u5237\u65b0\u7f13\u5b58<\/p>\n
Returns:
\n \u7f13\u5b58\u54cd\u5e94（203）\u6216\u65b0\u54cd\u5e94
\n """<\/p>\n
cache_key = hashlib.md5(request_url.encode()).hexdigest()
\n now = datetime.utcnow()<\/p>\n
# \u68c0\u67e5\u7f13\u5b58
\n if not force_refresh and cache_key in self.cache:
\n cache_entry = self.cache[cache_key]<\/p>\n
# \u68c0\u67e5\u662f\u5426\u8fc7\u671f
\n age = (now – cache_entry['cached_at']).total_seconds()
\n if age < self.cache_duration:
\n # \u8fd4\u56de\u7f13\u5b58\u54cd\u5e94（203）
\n return self._create_cached_response(
\n cache_entry['data'],
\n cache_entry['original_headers'],
\n age
\n )<\/p>\n
# \u83b7\u53d6\u65b0\u6570\u636e
\n new_data = self._fetch_from_upstream(request_url)
\n original_headers = self._get_upstream_headers(request_url)<\/p>\n
# \u66f4\u65b0\u7f13\u5b58
\n self.cache[cache_key] = {
\n 'data': new_data,
\n 'original_headers': original_headers,
\n 'cached_at': now
\n }<\/p>\n
# \u5982\u679c\u662f\u5f3a\u5236\u5237\u65b0\u6216\u7b2c\u4e00\u6b21\u83b7\u53d6，\u8fd4\u56de200
\n return jsonify(new_data), 200<\/p>\n
def _fetch_from_upstream(self, url):
\n """\u4ece\u4e0a\u6e38\u83b7\u53d6\u6570\u636e（\u6a21\u62df）"""
\n # \u5b9e\u9645\u4e2d\u4f1a\u8fdb\u884cHTTP\u8bf7\u6c42
\n return {
\n 'url': url,
\n 'data': 'Fresh data from upstream',
\n 'timestamp': datetime.utcnow().isoformat(),
\n 'source': 'upstream-server'
\n }<\/p>\n
def _get_upstream_headers(self, url):
\n """\u83b7\u53d6\u4e0a\u6e38\u5934\u90e8（\u6a21\u62df）"""
\n return {
\n 'Server': 'Upstream\/1.0',
\n 'X-Request-ID': 'req_123456'
\n }<\/p>\n
def _create_cached_response(self, data, original_headers, cache_age):
\n """\u521b\u5efa\u7f13\u5b58\u54cd\u5e94（203）"""<\/p>\n
response_data = {
\n **data,
\n '_cache_info': {
\n 'cached': True,
\n 'cache_age_seconds': cache_age,
\n 'max_age': self.cache_duration,
\n 'stale': cache_age > self.cache_duration * 0.8 # 80%\u8fc7\u671f
\n }
\n }<\/p>\n
return NonAuthoritativeResponse.create_response(
\n data=response_data,
\n original_headers=original_headers,
\n transformed_by='caching-proxy'
\n )<\/p>\n
# \u7f13\u5b58\u4ee3\u7406\u7aef\u70b9
\ncaching_proxy = CachingProxy(cache_duration=300)<\/p>\n
@app.route('\/cached\/<path:url>')
\ndef cached_proxy(url):
\n """\u7f13\u5b58\u4ee3\u7406\u7aef\u70b9"""
\n full_url = f'https:\/\/example.com\/{url}'
\n force_refresh = request.args.get('refresh', 'false').lower() == 'true'<\/p>\n
return caching_proxy.get_cached_response(full_url, force_refresh)<\/p>\n
if __name__ == '__main__':
\n app.run(debug=True, port=5001)<\/p>\n
javascript<\/p>\n
\/\/ \u5ba2\u6237\u7aef\u5904\u7406203\u54cd\u5e94\u7684\u793a\u4f8b
\nclass NonAuthoritativeResponseHandler {
\n \/**
\n * \u5904\u7406203 Non-Authoritative Information\u54cd\u5e94
\n *\/<\/p>\n
constructor() {
\n this.warningHandlers = {
\n '110': this.handleResponseIsStale,
\n '111': this.handleRevalidationFailed,
\n '112': this.handleDisconnectedOperation,
\n '113': this.handleHeuristicExpiration,
\n '199': this.handleMiscellaneousWarning,
\n '214': this.handleTransformationApplied,
\n '299': this.handleMiscellaneousPersistentWarning
\n };
\n }<\/p>\n
async handle203Response(response) {
\n console.log('Received 203 Non-Authoritative Information response');<\/p>\n
\/\/ \u89e3\u6790\u54cd\u5e94
\n const data = await response.json();<\/p>\n
\/\/ \u68c0\u67e5Warning\u5934\u90e8
\n const warningHeader = response.headers.get('Warning');
\n if (warningHeader) {
\n await this.handleWarnings(warningHeader, response);
\n }<\/p>\n
\/\/ \u68c0\u67e5Via\u5934\u90e8
\n const viaHeader = response.headers.get('Via');
\n if (viaHeader) {
\n console.log(`Response came via: ${viaHeader}`);
\n }<\/p>\n
\/\/ \u68c0\u67e5X-\u5934\u90e8
\n const infoSource = response.headers.get('X-Information-Source');
\n if (infoSource === 'Non-authoritative') {
\n console.warn('This response contains non-authoritative information');<\/p>\n
\/\/ \u6839\u636e\u4e1a\u52a1\u903b\u8f91\u51b3\u5b9a\u662f\u5426\u4f7f\u7528
\n if (this.requiresAuthoritativeData()) {
\n throw new Error('Authoritative data required, but received non-authoritative');
\n }
\n }<\/p>\n
\/\/ \u68c0\u67e5\u7f13\u5b58\u4fe1\u606f
\n if (data._cache_info) {
\n await this.handleCacheInfo(data._cache_info);
\n }<\/p>\n
return {
\n data: data,
\n isAuthoritative: false,
\n warnings: this.parseWarnings(warningHeader),
\n via: viaHeader,
\n metadata: {
\n etag: response.headers.get('ETag'),
\n lastModified: response.headers.get('Last-Modified'),
\n transformedBy: response.headers.get('X-Transformed-By')
\n }
\n };
\n }<\/p>\n
parseWarnings(warningHeader) {
\n if (!warningHeader) return [];<\/p>\n
\/\/ Warning: 214 Transformation applied, 315 Response is stale
\n const warnings = [];
\n const warningParts = warningHeader.split(',');<\/p>\n
for (const part of warningParts) {
\n const match = part.trim().match(\/^(\\\\d{3})\\\\s+(.+)$\/);
\n if (match) {
\n const [_, code, text] = match;
\n warnings.push({
\n code: parseInt(code, 10),
\n text: text.trim(),
\n agent: this.extractAgent(part)
\n });
\n }
\n }<\/p>\n
return warnings;
\n }<\/p>\n
extractAgent(warningText) {
\n \/\/ \u63d0\u53d6\u4ee3\u7406\u4fe1\u606f，\u4f8b\u5982：214 Transformation applied "proxy.example.com"
\n const match = warningText.match(\/"([^"]+)"\/);
\n return match ? match[1] : null;
\n }<\/p>\n
async handleWarnings(warningHeader, response) {
\n const warnings = this.parseWarnings(warningHeader);<\/p>\n
for (const warning of warnings) {
\n const handler = this.warningHandlers[warning.code];
\n if (handler) {
\n await handler.call(this, warning, response);
\n } else {
\n console.warn(`Unhandled warning ${warning.code}: ${warning.text}`);
\n }
\n }
\n }<\/p>\n
handleResponseIsStale(warning) {
\n console.warn('Response is stale:', warning.text);
\n \/\/ \u53ef\u4ee5\u8003\u8651\u91cd\u65b0\u9a8c\u8bc1
\n }<\/p>\n
handleRevalidationFailed(warning) {
\n console.warn('Revalidation failed:', warning.text);
\n \/\/ \u65e0\u6cd5\u91cd\u65b0\u9a8c\u8bc1，\u4f7f\u7528\u53ef\u80fd\u8fc7\u671f\u7684\u6570\u636e
\n }<\/p>\n
handleTransformationApplied(warning) {
\n console.log('Transformation applied by:', warning.agent);
\n \/\/ \u54cd\u5e94\u5df2\u88ab\u8f6c\u6362
\n }<\/p>\n
requiresAuthoritativeData() {
\n \/\/ \u6839\u636e\u5e94\u7528\u9700\u6c42\u51b3\u5b9a\u662f\u5426\u9700\u8981\u6743\u5a01\u6570\u636e
\n \/\/ \u4f8b\u5982：\u91d1\u878d\u4ea4\u6613\u9700\u8981\u6743\u5a01\u6570\u636e，\u800c\u65b0\u95fb\u6587\u7ae0\u53ef\u80fd\u4e0d\u9700\u8981
\n return false; \/\/ \u9ed8\u8ba4\u4e0d\u9700\u8981
\n }<\/p>\n
async handleCacheInfo(cacheInfo) {
\n console.log('Cache information:', cacheInfo);<\/p>\n
if (cacheInfo.stale) {
\n console.warn('Cache is stale, consider refreshing');<\/p>\n
\/\/ \u5982\u679c\u6570\u636e\u8fc7\u4e8e\u9648\u65e7，\u53ef\u4ee5\u89e6\u53d1\u540e\u53f0\u5237\u65b0
\n if (cacheInfo.cache_age_seconds > 600) { \/\/ 10\u5206\u949f
\n this.triggerBackgroundRefresh();
\n }
\n }
\n }<\/p>\n
triggerBackgroundRefresh() {
\n \/\/ \u5728\u540e\u53f0\u5237\u65b0\u6570\u636e
\n console.log('Triggering background refresh…');
\n \/\/ \u5b9e\u9645\u5b9e\u73b0\u4f1a\u53d1\u9001\u8bf7\u6c42\u5e76\u5728\u66f4\u65b0\u540e\u901a\u77e5UI
\n }<\/p>\n
\/\/ \u4f7f\u7528\u793a\u4f8b
\n async fetchWith203Handling(url, options = {}) {
\n try {
\n const response = await fetch(url, options);<\/p>\n
if (response.status === 203) {
\n const handler = new NonAuthoritativeResponseHandler();
\n return await handler.handle203Response(response);
\n } else if (response.ok) {
\n \/\/ \u6b63\u5e38\u54cd\u5e94
\n const data = await response.json();
\n return {
\n data: data,
\n isAuthoritative: true
\n };
\n } else {
\n throw new Error(`HTTP ${response.status}`);
\n }
\n } catch (error) {
\n console.error('Fetch failed:', error);
\n throw error;
\n }
\n }
\n}<\/p>\n
\/\/ \u4f7f\u7528\u793a\u4f8b
\ndocument.getElementById('load-data').addEventListener('click', async () => {
\n const handler = new NonAuthoritativeResponseHandler();<\/p>\n
try {
\n const result = await handler.fetchWith203Handling('\/proxy\/api\/data');<\/p>\n
if (!result.isAuthoritative) {
\n \/\/ \u663e\u793a\u975e\u6743\u5a01\u6570\u636e\u7684\u8b66\u544a
\n document.getElementById('warning-banner').style.display = 'block';
\n document.getElementById('warning-banner').textContent =
\n '\u663e\u793a\u7684\u6570\u636e\u53ef\u80fd\u4e0d\u662f\u6700\u65b0\u7684，\u6765\u81ea\u7f13\u5b58\u6216\u8f6c\u6362\u670d\u52a1';
\n }<\/p>\n
\/\/ \u4f7f\u7528\u6570\u636e
\n displayData(result.data);<\/p>\n
} catch (error) {
\n console.error('Failed to load data:', error);
\n alert('\u52a0\u8f7d\u6570\u636e\u5931\u8d25');
\n }
\n});<\/p>\n
function displayData(data) {
\n \/\/ \u663e\u793a\u6570\u636e\u7684\u903b\u8f91
\n const container = document.getElementById('data-container');
\n container.innerHTML = JSON.stringify(data, null, 2);
\n}<\/p>\n
\u6839\u636eRFC 7231\u7b2c6.3.6\u8282，205 Reset Content\u72b6\u6001\u7801\u7684\u5b9a\u4e49\u5982\u4e0b：<\/p>\n
205 (Reset Content)\u72b6\u6001\u7801\u8868\u793a\u670d\u52a1\u5668\u5df2\u6210\u529f\u5904\u7406\u8bf7\u6c42，\u5e76\u4e14\u7528\u6237\u4ee3\u7406\u5e94\u8be5\u91cd\u7f6e\u53d1\u9001\u6b64\u8bf7\u6c42\u7684\u6587\u6863\u89c6\u56fe\u3002\u8fd9\u4e2a\u54cd\u5e94\u4e3b\u8981\u662f\u4e3a\u4e86\u652f\u6301\u6570\u636e\u8f93\u5165（\u5982\u8868\u5355）\u7684\u8f93\u5165\u6e05\u7406，\u4ee5\u4fbf\u7528\u6237\u53ef\u4ee5\u8f7b\u677e\u5730\u5f00\u59cb\u53e6\u4e00\u6b21\u8f93\u5165\u3002<\/p>\n
\u89c6\u56fe\u91cd\u7f6e：\u5ba2\u6237\u7aef\u5e94\u91cd\u7f6e\u5bfc\u81f4\u8bf7\u6c42\u7684\u6587\u6863\u89c6\u56fe<\/p>\n<\/li>\n
\u65e0\u5185\u5bb9\u8fd4\u56de：\u54cd\u5e94\u4e0d\u80fd\u5305\u542b\u5b9e\u4f53\u4e3b\u4f53<\/p>\n<\/li>\n
\u7528\u6237\u754c\u9762\u5bfc\u5411：\u4e3b\u8981\u7528\u4e8e\u6539\u5584\u7528\u6237\u4f53\u9a8c<\/p>\n<\/li>\n
\u8868\u5355\u5904\u7406：\u7279\u522b\u9002\u5408\u8868\u5355\u63d0\u4ea4\u540e\u7684\u6e05\u7406<\/p>\n<\/li>\n
python<\/p>\n
# 205 Reset Content\u670d\u52a1\u5668\u5b9e\u73b0
\nfrom flask import Flask, request, jsonify, Response, render_template_string
\nfrom flask_wtf import FlaskForm
\nfrom wtforms import StringField, TextAreaField, SubmitField
\nfrom wtforms.validators import DataRequired
\nimport datetime<\/p>\n
app = Flask(__name__)
\napp.config['SECRET_KEY'] = 'your-secret-key-here'<\/p>\n
# \u8868\u5355\u5b9a\u4e49
\nclass ContactForm(FlaskForm):
\n name = StringField('Name', validators=[DataRequired()])
\n email = StringField('Email', validators=[DataRequired()])
\n message = TextAreaField('Message', validators=[DataRequired()])
\n submit = SubmitField('Submit')<\/p>\n
# HTML\u6a21\u677f
\nFORM_TEMPLATE = '''
\n<!DOCTYPE html>
\n<html>
\n<head>
\n <title>Contact Form<\/title>
\n <style>
\n body { font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto; padding: 20px; }
\n .form-group { margin-bottom: 15px; }
\n label { display: block; margin-bottom: 5px; font-weight: bold; }
\n input, textarea { width: 100%; padding: 8px; border: 1px solid #ddd; border-radius: 4px; }
\n .error { color: #dc3545; font-size: 0.9em; margin-top: 5px; }
\n .success { background: #d4edda; color: #155724; padding: 10px; border-radius: 4px; margin-bottom: 20px; }
\n .btn { background: #007bff; color: white; padding: 10px 20px; border: none; border-radius: 4px; cursor: pointer; }
\n .btn:hover { background: #0056b3; }
\n <\/style>
\n<\/head>
\n<body>
\n <h1>Contact Us<\/h1><\/p>\n
{% if success %}
\n <div class="success" id="success-message">
\n Thank you for your message! The form has been reset for your next message.
\n <\/div>
\n {% endif %}<\/p>\n
<form method="POST" id="contact-form">
\n {{ form.hidden_tag() }}<\/p>\n
<div class="form-group">
\n {{ form.name.label }}
\n {{ form.name(size=32) }}
\n {% for error in form.name.errors %}
\n <div class="error">{{ error }}<\/div>
\n {% endfor %}
\n <\/div><\/p>\n
<div class="form-group">
\n {{ form.email.label }}
\n {{ form.email(size=32) }}
\n {% for error in form.email.errors %}
\n <div class="error">{{ error }}<\/div>
\n {% endfor %}
\n <\/div><\/p>\n
<div class="form-group">
\n {{ form.message.label }}
\n {{ form.message(rows=5) }}
\n {% for error in form.message.errors %}
\n <div class="error">{{ error }}<\/div>
\n {% endfor %}
\n <\/div><\/p>\n
<div class="form-group">
\n {{ form.submit(class="btn") }}
\n <\/div>
\n <\/form><\/p>\n
<script>
\n \/\/ \u5982\u679c\u6536\u5230205\u54cd\u5e94，\u91cd\u7f6e\u8868\u5355
\n document.getElementById('contact-form').addEventListener('submit', async function(e) {
\n e.preventDefault();<\/p>\n
const formData = new FormData(this);<\/p>\n
try {
\n const response = await fetch(this.action, {
\n method: this.method,
\n body: formData,
\n headers: {
\n 'X-Requested-With': 'XMLHttpRequest'
\n }
\n });<\/p>\n
if (response.status === 205) {
\n \/\/ \u91cd\u7f6e\u8868\u5355
\n this.reset();<\/p>\n
\/\/ \u663e\u793a\u6210\u529f\u6d88\u606f
\n const successDiv = document.createElement('div');
\n successDiv.className = 'success';
\n successDiv.id = 'success-message';
\n successDiv.textContent = 'Thank you for your message! The form has been reset for your next message.';<\/p>\n
const existingSuccess = document.getElementById('success-message');
\n if (existingSuccess) {
\n existingSuccess.replaceWith(successDiv);
\n } else {
\n this.parentNode.insertBefore(successDiv, this);
\n }<\/p>\n
\/\/ 5\u79d2\u540e\u9690\u85cf\u6210\u529f\u6d88\u606f
\n setTimeout(() => {
\n successDiv.style.transition = 'opacity 0.5s';
\n successDiv.style.opacity = '0';
\n setTimeout(() => successDiv.remove(), 500);
\n }, 5000);<\/p>\n
} else {
\n \/\/ \u5904\u7406\u5176\u4ed6\u54cd\u5e94
\n const data = await response.json();
\n if (data.errors) {
\n \/\/ \u663e\u793a\u9519\u8bef
\n alert('Error: ' + JSON.stringify(data.errors));
\n }
\n }<\/p>\n
} catch (error) {
\n console.error('Submission error:', error);
\n alert('An error occurred. Please try again.');
\n }
\n });
\n <\/script>
\n<\/body>
\n<\/html>
\n'''<\/p>\n
@app.route('\/contact', methods=['GET', 'POST'])
\ndef contact():
\n form = ContactForm()<\/p>\n
if request.method == 'POST':
\n # \u68c0\u67e5\u662f\u5426\u662fAJAX\u8bf7\u6c42
\n is_ajax = request.headers.get('X-Requested-With') == 'XMLHttpRequest'<\/p>\n
if form.validate():
\n # \u5904\u7406\u8868\u5355\u6570\u636e（\u4f8b\u5982\u4fdd\u5b58\u5230\u6570\u636e\u5e93）
\n form_data = {
\n 'name': form.name.data,
\n 'email': form.email.data,
\n 'message': form.message.data,
\n 'timestamp': datetime.datetime.utcnow().isoformat(),
\n 'ip_address': request.remote_addr
\n }<\/p>\n
# \u6a21\u62df\u4fdd\u5b58\u5230\u6570\u636e\u5e93
\n save_contact_message(form_data)<\/p>\n
if is_ajax:
\n # \u5bf9\u4e8eAJAX\u8bf7\u6c42，\u8fd4\u56de205 Reset Content
\n response = Response(status=205)
\n response.headers['X-Form-Processed'] = 'true'
\n response.headers['X-Message-ID'] = 'msg_' + str(hash(str(form_data)))
\n return response
\n else:
\n # \u5bf9\u4e8e\u4f20\u7edf\u8868\u5355\u63d0\u4ea4，\u91cd\u5b9a\u5411\u5230\u76f8\u540c\u9875\u9762\u5e76\u663e\u793a\u6210\u529f\u6d88\u606f
\n return render_template_string(FORM_TEMPLATE, form=ContactForm(), success=True)
\n else:
\n # \u9a8c\u8bc1\u5931\u8d25
\n if is_ajax:
\n return jsonify({
\n 'success': False,
\n 'errors': form.errors
\n }), 400
\n else:
\n # \u91cd\u65b0\u663e\u793a\u5e26\u6709\u9519\u8bef\u4fe1\u606f\u7684\u8868\u5355
\n return render_template_string(FORM_TEMPLATE, form=form, success=False)<\/p>\n
# GET\u8bf7\u6c42：\u663e\u793a\u8868\u5355
\n return render_template_string(FORM_TEMPLATE, form=form, success=False)<\/p>\n
def save_contact_message(data):
\n """\u4fdd\u5b58\u8054\u7cfb\u6d88\u606f（\u6a21\u62df）"""
\n # \u5b9e\u9645\u4e2d\u4f1a\u4fdd\u5b58\u5230\u6570\u636e\u5e93
\n print(f"Saving contact message: {data}")<\/p>\n
# \u91cd\u7f6e\u6e38\u620f\u72b6\u6001\u793a\u4f8b
\n@app.route('\/api\/game\/reset', methods=['POST'])
\ndef reset_game():
\n """
\n \u91cd\u7f6e\u6e38\u620f\u72b6\u6001<\/p>\n
\u5178\u578b\u573a\u666f：
\n 1. \u6e38\u620f\u7ed3\u675f\u540e\u91cd\u7f6e
\n 2. \u7528\u6237\u60f3\u8981\u91cd\u65b0\u5f00\u59cb
\n 3. \u6e05\u9664\u6240\u6709\u8fdb\u5ea6
\n """<\/p>\n
# \u9a8c\u8bc1\u7528\u6237\u8eab\u4efd
\n user_id = request.headers.get('X-User-ID')
\n if not user_id:
\n return jsonify({'error': 'Authentication required'}), 401<\/p>\n
# \u91cd\u7f6e\u6e38\u620f\u72b6\u6001（\u6a21\u62df）
\n reset_user_game_state(user_id)<\/p>\n
# \u8fd4\u56de205 Reset Content
\n response = Response(status=205)
\n response.headers['X-Game-Reset'] = 'true'
\n response.headers['X-Reset-Timestamp'] = datetime.datetime.utcnow().isoformat()
\n response.headers['X-User-ID'] = user_id<\/p>\n
return response<\/p>\n
def reset_user_game_state(user_id):
\n """\u91cd\u7f6e\u7528\u6237\u6e38\u620f\u72b6\u6001（\u6a21\u62df）"""
\n # \u5b9e\u9645\u4e2d\u4f1a\u66f4\u65b0\u6570\u636e\u5e93
\n print(f"Resetting game state for user: {user_id}")<\/p>\n
# \u753b\u5e03\u91cd\u7f6e\u793a\u4f8b
\n@app.route('\/api\/canvas\/reset', methods=['POST'])
\ndef reset_canvas():
\n """
\n \u91cd\u7f6e\u753b\u5e03<\/p>\n
\u5178\u578b\u573a\u666f：
\n 1. \u7ed8\u56fe\u5e94\u7528\u4e2d\u7684\u6e05\u7a7a\u753b\u5e03
\n 2. \u767d\u677f\u5e94\u7528\u4e2d\u7684\u91cd\u7f6e
\n 3. \u56fe\u8868\u7f16\u8f91\u5668\u4e2d\u7684\u6e05\u9664
\n """<\/p>\n
# \u83b7\u53d6\u753b\u5e03ID
\n canvas_id = request.json.get('canvas_id')
\n if not canvas_id:
\n return jsonify({'error': 'Canvas ID required'}), 400<\/p>\n
# \u91cd\u7f6e\u753b\u5e03（\u6a21\u62df）
\n clear_canvas_data(canvas_id)<\/p>\n
# \u8fd4\u56de205 Reset Content
\n response = Response(status=205)
\n response.headers['X-Canvas-Reset'] = 'true'
\n response.headers['X-Canvas-ID'] = canvas_id
\n response.headers['X-Reset-At'] = datetime.datetime.utcnow().isoformat()<\/p>\n
return response<\/p>\n
def clear_canvas_data(canvas_id):
\n """\u6e05\u9664\u753b\u5e03\u6570\u636e（\u6a21\u62df）"""
\n # \u5b9e\u9645\u4e2d\u4f1a\u6e05\u9664\u6570\u636e\u5e93\u4e2d\u7684\u753b\u5e03\u6570\u636e
\n print(f"Clearing canvas data for: {canvas_id}")<\/p>\n
# \u6279\u91cf\u8868\u5355\u91cd\u7f6e
\n@app.route('\/api\/forms\/batch-reset', methods=['POST'])
\ndef batch_reset_forms():
\n """
\n \u6279\u91cf\u91cd\u7f6e\u591a\u4e2a\u8868\u5355<\/p>\n
\u5178\u578b\u573a\u666f：
\n 1. \u591a\u6b65\u9aa4\u5411\u5bfc\u4e2d\u7684\u91cd\u7f6e
\n 2. \u5305\u542b\u591a\u4e2a\u8868\u5355\u7684\u9875\u9762
\n 3. \u95ee\u5377\u5e94\u7528\u4e2d\u7684\u6e05\u9664\u6240\u6709\u7b54\u6848
\n """<\/p>\n
# \u83b7\u53d6\u8981\u91cd\u7f6e\u7684\u8868\u5355ID\u5217\u8868
\n form_ids = request.json.get('form_ids', [])<\/p>\n
if not form_ids:
\n return jsonify({'error': 'No form IDs provided'}), 400<\/p>\n
# \u91cd\u7f6e\u6bcf\u4e2a\u8868\u5355（\u6a21\u62df）
\n reset_results = []
\n for form_id in form_ids:
\n try:
\n reset_form_data(form_id)
\n reset_results.append({
\n 'form_id': form_id,
\n 'status': 'reset',
\n 'timestamp': datetime.datetime.utcnow().isoformat()
\n })
\n except Exception as e:
\n reset_results.append({
\n 'form_id': form_id,
\n 'status': 'failed',
\n 'error': str(e)
\n })<\/p>\n
# \u8fd4\u56de205 Reset Content（\u5373\u4f7f\u90e8\u5206\u5931\u8d25\u4e5f\u91cd\u7f6e\u5ba2\u6237\u7aef\u89c6\u56fe）
\n response = Response(status=205)
\n response.headers['X-Batch-Reset'] = 'true'
\n response.headers['X-Reset-Count'] = str(len([r for r in reset_results if r['status'] == 'reset']))
\n response.headers['X-Failed-Count'] = str(len([r for r in reset_results if r['status'] == 'failed']))<\/p>\n
return response<\/p>\n
def reset_form_data(form_id):
\n """\u91cd\u7f6e\u8868\u5355\u6570\u636e（\u6a21\u62df）"""
\n # \u5b9e\u9645\u4e2d\u4f1a\u6e05\u9664\u8868\u5355\u6570\u636e
\n print(f"Resetting form data for: {form_id}")<\/p>\n
if __name__ == '__main__':
\n app.run(debug=True, port=5002)<\/p>\n
javascript<\/p>\n
\/\/ \u5ba2\u6237\u7aef\u5904\u7406205\u54cd\u5e94\u7684\u793a\u4f8b
\nclass ResetContentHandler {
\n \/**
\n * \u5904\u7406205 Reset Content\u54cd\u5e94
\n *\/<\/p>\n
constructor() {
\n this.formSelectors = [
\n 'form[data-reset-on-205]',
\n 'form.reset-on-success',
\n '.resettable-form'
\n ];<\/p>\n
this.initializeEventListeners();
\n }<\/p>\n
initializeEventListeners() {
\n \/\/ \u76d1\u542c\u6240\u6709\u8868\u5355\u7684\u63d0\u4ea4\u4e8b\u4ef6
\n document.querySelectorAll('form').forEach(form => {
\n form.addEventListener('submit', (e) => this.handleFormSubmit(e));
\n });<\/p>\n
\/\/ \u76d1\u542c\u81ea\u5b9a\u4e49\u91cd\u7f6e\u4e8b\u4ef6
\n document.addEventListener('resetContentRequired', (e) => {
\n this.resetContent(e.detail.element, e.detail.options);
\n });
\n }<\/p>\n
async handleFormSubmit(event) {
\n const form = event.target;<\/p>\n
\/\/ \u68c0\u67e5\u662f\u5426\u5e94\u8be5\u62e6\u622a\u63d0\u4ea4
\n if (!this.shouldInterceptForm(form)) {
\n return; \/\/ \u8ba9\u8868\u5355\u6b63\u5e38\u63d0\u4ea4
\n }<\/p>\n
event.preventDefault();<\/p>\n
try {
\n const response = await this.submitForm(form);<\/p>\n
if (response.status === 205) {
\n \/\/ \u91cd\u7f6e\u8868\u5355
\n this.resetForm(form, response);<\/p>\n
\/\/ \u663e\u793a\u6210\u529f\u6d88\u606f
\n this.showSuccessMessage(form, response);<\/p>\n
\/\/ \u89e6\u53d1\u81ea\u5b9a\u4e49\u4e8b\u4ef6
\n this.triggerResetComplete(form, response);<\/p>\n
} else if (response.ok) {
\n \/\/ \u5176\u4ed6\u6210\u529f\u54cd\u5e94
\n const data = await response.json();
\n this.handleSuccessResponse(form, data);
\n } else {
\n \/\/ \u9519\u8bef\u54cd\u5e94
\n const error = await response.json();
\n this.handleErrorResponse(form, error);
\n }<\/p>\n
} catch (error) {
\n console.error('Form submission failed:', error);
\n this.showError(form, 'Network error. Please try again.');
\n }
\n }<\/p>\n
shouldInterceptForm(form) {
\n \/\/ \u68c0\u67e5\u8868\u5355\u662f\u5426\u5e94\u8be5\u88ab\u62e6\u622a
\n return form.hasAttribute('data-ajax-submit') ||
\n form.classList.contains('ajax-form') ||
\n this.formSelectors.some(selector => form.matches(selector));
\n }<\/p>\n
async submitForm(form) {
\n const formData = new FormData(form);
\n const method = form.method.toUpperCase();
\n const url = form.action;<\/p>\n
\/\/ \u5bf9\u4e8eGET\u8bf7\u6c42，\u6784\u5efa\u67e5\u8be2\u5b57\u7b26\u4e32
\n if (method === 'GET') {
\n const params = new URLSearchParams(formData);
\n const fullUrl = url + (url.includes('?') ? '&' : '?') + params.toString();
\n return fetch(fullUrl, { method: 'GET' });
\n }<\/p>\n
\/\/ \u5bf9\u4e8ePOST\/PUT\/PATCH\u8bf7\u6c42
\n return fetch(url, {
\n method: method,
\n body: method === 'POST' ? formData : JSON.stringify(Object.fromEntries(formData)),
\n headers: {
\n 'X-Requested-With': 'XMLHttpRequest',
\n …(method !== 'POST' && { 'Content-Type': 'application\/json' })
\n }
\n });
\n }<\/p>\n
resetForm(form, response) {
\n \/\/ \u91cd\u7f6e\u8868\u5355\u5b57\u6bb5
\n form.reset();<\/p>\n
\/\/ \u6e05\u9664\u81ea\u5b9a\u4e49\u5b57\u6bb5\u72b6\u6001
\n this.clearCustomFieldStates(form);<\/p>\n
\/\/ \u91cd\u7f6e\u9a8c\u8bc1\u72b6\u6001
\n this.resetValidation(form);<\/p>\n
\/\/ \u5982\u679c\u6709\u6587\u4ef6\u8f93\u5165，\u6e05\u9664\u6587\u4ef6
\n this.clearFileInputs(form);<\/p>\n
\/\/ \u89e6\u53d1\u8868\u5355\u91cd\u7f6e\u4e8b\u4ef6
\n form.dispatchEvent(new Event('reset', { bubbles: true }));<\/p>\n
\/\/ \u6dfb\u52a0\u89c6\u89c9\u53cd\u9988
\n this.addResetAnimation(form);
\n }<\/p>\n
clearCustomFieldStates(form) {
\n \/\/ \u6e05\u9664\u81ea\u5b9a\u4e49\u5b57\u6bb5（\u5982\u5bcc\u6587\u672c\u7f16\u8f91\u5668\u3001\u65e5\u671f\u9009\u62e9\u5668\u7b49）
\n form.querySelectorAll('[data-custom-field]').forEach(field => {
\n if (field.type === 'textarea' && field.dataset.richText) {
\n \/\/ \u91cd\u7f6e\u5bcc\u6587\u672c\u7f16\u8f91\u5668
\n if (window.tinymce && window.tinymce.get(field.id)) {
\n window.tinymce.get(field.id).setContent('');
\n }
\n }<\/p>\n
if (field.type === 'select-one' && field.dataset.select2) {
\n \/\/ \u91cd\u7f6eSelect2
\n if ($ && $(field).data('select2')) {
\n $(field).val(null).trigger('change');
\n }
\n }
\n });
\n }<\/p>\n
resetValidation(form) {
\n \/\/ \u6e05\u9664\u9a8c\u8bc1\u9519\u8bef
\n form.querySelectorAll('.error, .is-invalid').forEach(el => {
\n el.classList.remove('error', 'is-invalid');
\n });<\/p>\n
\/\/ \u6e05\u9664\u9519\u8bef\u6d88\u606f
\n form.querySelectorAll('.error-message, .invalid-feedback').forEach(el => {
\n el.remove();
\n });
\n }<\/p>\n
clearFileInputs(form) {
\n \/\/ \u6e05\u9664\u6587\u4ef6\u8f93\u5165
\n form.querySelectorAll('input[type="file"]').forEach(input => {
\n input.value = '';<\/p>\n
\/\/ \u89e6\u53d1\u66f4\u6539\u4e8b\u4ef6
\n input.dispatchEvent(new Event('change', { bubbles: true }));
\n });
\n }<\/p>\n
addResetAnimation(form) {
\n \/\/ \u6dfb\u52a0\u91cd\u7f6e\u52a8\u753b
\n form.style.transition = 'all 0.3s';
\n form.style.backgroundColor = '#f8f9fa';<\/p>\n
setTimeout(() => {
\n form.style.backgroundColor = '';
\n }, 300);
\n }<\/p>\n
showSuccessMessage(form, response) {
\n \/\/ \u663e\u793a\u6210\u529f\u6d88\u606f
\n const successDiv = document.createElement('div');
\n successDiv.className = 'alert alert-success success-message';
\n successDiv.setAttribute('role', 'alert');<\/p>\n
\/\/ \u4ece\u54cd\u5e94\u5934\u83b7\u53d6\u6d88\u606f
\n const message = response.headers.get('X-Success-Message') ||
\n 'Form submitted successfully! The form has been reset.';<\/p>\n
successDiv.textContent = message;<\/p>\n
\/\/ \u63d2\u5165\u5230\u8868\u5355\u524d
\n form.parentNode.insertBefore(successDiv, form);<\/p>\n
\/\/ 5\u79d2\u540e\u81ea\u52a8\u9690\u85cf
\n setTimeout(() => {
\n successDiv.style.opacity = '0';
\n successDiv.style.transition = 'opacity 0.5s';<\/p>\n
setTimeout(() => {
\n successDiv.remove();
\n }, 500);
\n }, 5000);
\n }<\/p>\n
triggerResetComplete(form, response) {
\n \/\/ \u89e6\u53d1\u81ea\u5b9a\u4e49\u4e8b\u4ef6
\n const event = new CustomEvent('formResetComplete', {
\n detail: {
\n form: form,
\n response: response,
\n timestamp: new Date().toISOString(),
\n headers: Object.fromEntries(response.headers.entries())
\n },
\n bubbles: true
\n });<\/p>\n
form.dispatchEvent(event);
\n }<\/p>\n
handleSuccessResponse(form, data) {
\n \/\/ \u5904\u7406\u5176\u4ed6\u6210\u529f\u54cd\u5e94
\n console.log('Form submitted successfully:', data);<\/p>\n
\/\/ \u663e\u793a\u6d88\u606f
\n this.showSuccessMessage(form, {
\n headers: new Headers({ 'X-Success-Message': data.message || 'Success!' })
\n });
\n }<\/p>\n
handleErrorResponse(form, error) {
\n \/\/ \u663e\u793a\u9519\u8bef
\n console.error('Form submission error:', error);<\/p>\n
\/\/ \u663e\u793a\u9519\u8bef\u6d88\u606f
\n const errorDiv = document.createElement('div');
\n errorDiv.className = 'alert alert-danger';
\n errorDiv.textContent = error.message || 'An error occurred. Please check your input.';<\/p>\n
form.parentNode.insertBefore(errorDiv, form);<\/p>\n
\/\/ 3\u79d2\u540e\u81ea\u52a8\u9690\u85cf
\n setTimeout(() => {
\n errorDiv.remove();
\n }, 3000);
\n }<\/p>\n
showError(form, message) {
\n \/\/ \u663e\u793a\u901a\u7528\u9519\u8bef
\n alert(message); \/\/ \u5728\u5b9e\u9645\u5e94\u7528\u4e2d\u66ff\u6362\u4e3a\u66f4\u597d\u7684UI
\n }<\/p>\n
\/\/ \u901a\u7528\u5185\u5bb9\u91cd\u7f6e\u65b9\u6cd5
\n resetContent(element, options = {}) {
\n const defaults = {
\n clearInputs: true,
\n resetSelects: true,
\n clearTextareas: true,
\n removeDynamicContent: true,
\n animation: true
\n };<\/p>\n
const settings = { …defaults, …options };<\/p>\n
\/\/ \u91cd\u7f6e\u8868\u5355\u5143\u7d20
\n if (element.tagName === 'FORM') {
\n element.reset();<\/p>\n
if (settings.clearInputs) {
\n element.querySelectorAll('input:not([type="hidden"])').forEach(input => {
\n if (input.type !== 'checkbox' && input.type !== 'radio') {
\n input.value = '';
\n } else {
\n input.checked = false;
\n }
\n });
\n }<\/p>\n
if (settings.resetSelects) {
\n element.querySelectorAll('select').forEach(select => {
\n select.selectedIndex = 0;
\n });
\n }<\/p>\n
if (settings.clearTextareas) {
\n element.querySelectorAll('textarea').forEach(textarea => {
\n textarea.value = '';
\n });
\n }
\n }<\/p>\n
\/\/ \u91cd\u7f6e\u52a8\u6001\u5185\u5bb9
\n if (settings.removeDynamicContent) {
\n element.querySelectorAll('[data-dynamic]').forEach(el => {
\n el.remove();
\n });
\n }<\/p>\n
\/\/ \u6dfb\u52a0\u52a8\u753b\u6548\u679c
\n if (settings.animation) {
\n element.style.transition = 'all 0.3s';
\n element.style.opacity = '0.8';<\/p>\n
setTimeout(() => {
\n element.style.opacity = '1';
\n }, 300);
\n }<\/p>\n
\/\/ \u89e6\u53d1\u91cd\u7f6e\u4e8b\u4ef6
\n element.dispatchEvent(new CustomEvent('contentReset', {
\n detail: { settings, timestamp: new Date().toISOString() }
\n }));
\n }
\n}<\/p>\n
\/\/ \u4f7f\u7528\u793a\u4f8b
\ndocument.addEventListener('DOMContentLoaded', () => {
\n \/\/ \u521d\u59cb\u5316\u5904\u7406\u5668
\n const resetHandler = new ResetContentHandler();<\/p>\n
\/\/ \u91cd\u7f6e\u753b\u5e03\u793a\u4f8b
\n document.getElementById('reset-canvas-btn').addEventListener('click', async () => {
\n try {
\n const response = await fetch('\/api\/canvas\/reset', {
\n method: 'POST',
\n headers: {
\n 'Content-Type': 'application\/json'
\n },
\n body: JSON.stringify({
\n canvas_id: 'canvas-123'
\n })
\n });<\/p>\n
if (response.status === 205) {
\n \/\/ \u6e05\u7a7a\u753b\u5e03
\n const canvas = document.getElementById('drawing-canvas');
\n const ctx = canvas.getContext('2d');
\n ctx.clearRect(0, 0, canvas.width, canvas.height);<\/p>\n
\/\/ \u663e\u793a\u6d88\u606f
\n alert('Canvas cleared successfully!');
\n }
\n } catch (error) {
\n console.error('Failed to reset canvas:', error);
\n }
\n });<\/p>\n
\/\/ \u91cd\u7f6e\u6e38\u620f\u793a\u4f8b
\n document.getElementById('reset-game-btn').addEventListener('click', async () => {
\n if (!confirm('Are you sure you want to reset the game? All progress will be lost.')) {
\n return;
\n }<\/p>\n
try {
\n const response = await fetch('\/api\/game\/reset', {
\n method: 'POST',
\n headers: {
\n 'X-User-ID': 'user-123'
\n }
\n });<\/p>\n
if (response.status === 205) {
\n \/\/ \u91cd\u7f6e\u6e38\u620f\u754c\u9762
\n resetHandler.resetContent(document.getElementById('game-container'), {
\n clearInputs: true,
\n animation: true
\n });<\/p>\n
\/\/ \u663e\u793a\u91cd\u7f6e\u6d88\u606f
\n document.getElementById('game-message').textContent = 'Game reset! Ready to start new game.';
\n }
\n } catch (error) {
\n console.error('Failed to reset game:', error);
\n }
\n });<\/p>\n
\/\/ \u6279\u91cf\u91cd\u7f6e\u793a\u4f8b
\n document.getElementById('reset-all-forms').addEventListener('click', () => {
\n \/\/ \u89e6\u53d1\u81ea\u5b9a\u4e49\u91cd\u7f6e\u4e8b\u4ef6
\n document.dispatchEvent(new CustomEvent('resetContentRequired', {
\n detail: {
\n element: document.body,
\n options: {
\n clearInputs: true,
\n resetSelects: true,
\n animation: true
\n }
\n }
\n }));
\n });
\n});<\/p>\n
\u6839\u636eRFC 4918（WebDAV）\u7b2c11.1\u8282，207 Multi-Status\u72b6\u6001\u7801\u7684\u5b9a\u4e49\u5982\u4e0b：<\/p>\n
207 (Multi-Status)\u72b6\u6001\u7801\u63d0\u4f9b\u6709\u5173\u591a\u4e2a\u8d44\u6e90\u7684\u72b6\u6001\u4fe1\u606f，\u9002\u7528\u4e8e\u9700\u8981\u591a\u4e2a\u72ec\u7acb\u72b6\u6001\u7801\u7684\u60c5\u51b5\u3002\u54cd\u5e94\u4f53\u662f\u4e00\u4e2aXML\u6587\u6863，\u5305\u542b\u591a\u4e2a"response"\u5143\u7d20，\u6bcf\u4e2a\u5143\u7d20\u63cf\u8ff0\u4e00\u4e2a\u72ec\u7acb\u8d44\u6e90\u8bf7\u6c42\u7684\u7ed3\u679c\u3002<\/p>\n
\u591a\u8d44\u6e90\u72b6\u6001：\u5355\u4e2a\u54cd\u5e94\u5305\u542b\u591a\u4e2a\u72ec\u7acb\u72b6\u6001<\/p>\n<\/li>\n
XML\u683c\u5f0f：\u54cd\u5e94\u4f53\u5fc5\u987b\u662fXML\u683c\u5f0f<\/p>\n<\/li>\n
WebDAV\u6838\u5fc3：\u4e3b\u8981\u7528\u4e8eWebDAV\u534f\u8bae<\/p>\n<\/li>\n
\u6279\u91cf\u64cd\u4f5c：\u9002\u5408\u6279\u91cf\u521b\u5efa\u3001\u66f4\u65b0\u3001\u5220\u9664\u6216\u67e5\u8be2<\/p>\n<\/li>\n
python<\/p>\n
# 207 Multi-Status\u670d\u52a1\u5668\u5b9e\u73b0
\nfrom flask import Flask, request, Response
\nimport xml.etree.ElementTree as ET
\nfrom xml.dom import minidom
\nfrom datetime import datetime
\nfrom typing import List, Dict, Any
\nimport json<\/p>\n
app = Flask(__name__)<\/p>\n
class MultiStatusResponse:
\n """207 Multi-Status\u54cd\u5e94\u751f\u6210\u5668"""<\/p>\n
DAV_NAMESPACE = 'DAV:'
\n DAV_PREFIX = 'd'<\/p>\n
def __init__(self):
\n # \u6ce8\u518c\u547d\u540d\u7a7a\u95f4
\n ET.register_namespace(self.DAV_PREFIX, self.DAV_NAMESPACE)<\/p>\n
def create_response(self, responses: List[Dict[str, Any]]) -> Response:
\n """
\n \u521b\u5efa207 Multi-Status\u54cd\u5e94<\/p>\n
Args:
\n responses: \u54cd\u5e94\u5217\u8868，\u6bcf\u4e2a\u5143\u7d20\u5305\u542b:
\n – href: \u8d44\u6e90URL
\n – status: HTTP\u72b6\u6001\u7801
\n – message: \u72b6\u6001\u6d88\u606f
\n – props: \u5c5e\u6027\u5b57\u5178（\u53ef\u9009）
\n – error: \u9519\u8bef\u4fe1\u606f（\u53ef\u9009）<\/p>\n
Returns:
\n Flask Response\u5bf9\u8c61
\n """<\/p>\n
# \u521b\u5efa\u6839\u5143\u7d20
\n root = ET.Element(f'{{{self.DAV_NAMESPACE}}}multistatus')<\/p>\n
for resp in responses:
\n response_elem = self._create_response_element(resp)
\n root.append(response_elem)<\/p>\n
# \u8f6c\u6362\u4e3a\u683c\u5f0f\u5316\u7684XML
\n xml_str = self._prettify_xml(root)<\/p>\n
# \u521b\u5efa\u54cd\u5e94
\n return Response(
\n xml_str,
\n status=207,
\n content_type='application\/xml; charset="utf-8"',
\n headers={
\n 'Date': datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S GMT'),
\n 'Server': 'WebDAV-Server\/1.0'
\n }
\n )<\/p>\n
def _create_response_element(self, response_info: Dict[str, Any]) -> ET.Element:
\n """\u521b\u5efa\u5355\u4e2aresponse\u5143\u7d20"""
\n response_elem = ET.Element(f'{{{self.DAV_NAMESPACE}}}response')<\/p>\n
# href\u5143\u7d20
\n href_elem = ET.SubElement(response_elem, f'{{{self.DAV_NAMESPACE}}}href')
\n href_elem.text = response_info.get('href', '')<\/p>\n
# \u72b6\u6001\u5143\u7d20
\n if 'status' in response_info:
\n status_elem = ET.SubElement(response_elem, f'{{{self.DAV_NAMESPACE}}}status')
\n status_code = response_info['status']
\n status_msg = response_info.get('message', 'OK')
\n status_elem.text = f'HTTP\/1.1 {status_code} {status_msg}'<\/p>\n
# \u5c5e\u6027\u5143\u7d20（\u5982\u679c\u6709）
\n if 'props' in response_info:
\n propstat_elem = ET.SubElement(response_elem, f'{{{self.DAV_NAMESPACE}}}propstat')<\/p>\n
# prop\u5143\u7d20
\n prop_elem = ET.SubElement(propstat_elem, f'{{{self.DAV_NAMESPACE}}}prop')
\n for prop_name, prop_value in response_info['props'].items():
\n prop_item = ET.SubElement(prop_elem, f'{{{self.DAV_NAMESPACE}}}{prop_name}')
\n prop_item.text = str(prop_value)<\/p>\n
# \u5c5e\u6027\u72b6\u6001
\n prop_status = ET.SubElement(propstat_elem, f'{{{self.DAV_NAMESPACE}}}status')
\n prop_status.text = f'HTTP\/1.1 {response_info.get("prop_status", 200)} OK'<\/p>\n
# \u9519\u8bef\u5143\u7d20（\u5982\u679c\u6709）
\n if 'error' in response_info:
\n error_elem = ET.SubElement(response_elem, f'{{{self.DAV_NAMESPACE}}}error')
\n error_desc = ET.SubElement(error_elem, f'{{{self.DAV_NAMESPACE}}}description')
\n error_desc.text = response_info['error']<\/p>\n
return response_elem<\/p>\n
def _prettify_xml(self, elem: ET.Element) -> str:
\n """\u683c\u5f0f\u5316XML"""
\n rough_string = ET.tostring(elem, 'utf-8')
\n parsed = minidom.parseString(rough_string)
\n return parsed.toprettyxml(indent=' ')<\/p>\n
def parse_request(self, xml_body: str) -> List[Dict[str, Any]]:
\n """
\n \u89e3\u6790Multi-Status\u8bf7\u6c42\u4f53<\/p>\n
Args:
\n xml_body: XML\u8bf7\u6c42\u4f53<\/p>\n
Returns:
\n \u89e3\u6790\u540e\u7684\u8bf7\u6c42\u5217\u8868
\n """
\n try:
\n root = ET.fromstring(xml_body)
\n requests = []<\/p>\n
# \u67e5\u627e\u6240\u6709href\u5143\u7d20
\n for href_elem in root.findall(f'.\/\/{{{self.DAV_NAMESPACE}}}href'):
\n request_info = {
\n 'href': href_elem.text,
\n 'method': self._extract_method(href_elem),
\n 'properties': self._extract_properties(href_elem)
\n }
\n requests.append(request_info)<\/p>\n
return requests<\/p>\n
except ET.ParseError as e:
\n raise ValueError(f'Invalid XML: {e}')<\/p>\n
def _extract_method(self, href_elem: ET.Element) -> str:
\n """\u63d0\u53d6\u8bf7\u6c42\u65b9\u6cd5"""
\n # \u5728\u5b9e\u9645WebDAV\u4e2d，\u8fd9\u53ef\u80fd\u6765\u81ea\u4e0d\u540c\u7684\u4f4d\u7f6e
\n parent = href_elem.getparent()
\n if parent is not None:
\n method_elem = parent.find(f'{{{self.DAV_NAMESPACE}}}method')
\n if method_elem is not None:
\n return method_elem.text
\n return 'GET' # \u9ed8\u8ba4<\/p>\n
def _extract_properties(self, href_elem: ET.Element) -> Dict[str, str]:
\n """\u63d0\u53d6\u8bf7\u6c42\u5c5e\u6027"""
\n properties = {}
\n parent = href_elem.getparent()<\/p>\n
if parent is not None:
\n prop_elem = parent.find(f'{{{self.DAV_NAMESPACE}}}prop')
\n if prop_elem is not None:
\n for child in prop_elem:
\n # \u79fb\u9664\u547d\u540d\u7a7a\u95f4\u524d\u7f00
\n tag = child.tag
\n if '}' in tag:
\n tag = tag.split('}', 1)[1]
\n properties[tag] = child.text<\/p>\n
return properties<\/p>\n
# \u521b\u5efa\u54cd\u5e94\u751f\u6210\u5668\u5b9e\u4f8b
\nmultistatus = MultiStatusResponse()<\/p>\n
# WebDAV PROPFIND\u65b9\u6cd5\u5b9e\u73b0
\n@app.route('\/dav\/<path:path>', methods=['PROPFIND'])
\ndef webdav_propfind(path):
\n """
\n WebDAV PROPFIND\u65b9\u6cd5<\/p>\n
\u7528\u4e8e\u68c0\u7d22\u8d44\u6e90\u7684\u5c5e\u6027
\n """<\/p>\n
# \u89e3\u6790\u8bf7\u6c42\u6df1\u5ea6
\n depth = request.headers.get('Depth', '1')<\/p>\n
# \u6784\u5efa\u54cd\u5e94\u5217\u8868
\n responses = []<\/p>\n
# \u6dfb\u52a0\u8bf7\u6c42\u7684\u8d44\u6e90
\n base_url = f'\/dav\/{path}'
\n responses.append({
\n 'href': base_url,
\n 'status': 200,
\n 'message': 'OK',
\n 'props': {
\n 'displayname': path.split('\/')[-1] or 'Root',
\n 'resourcetype': '<collection\/>' if path.endswith('\/') else '',
\n 'getcontentlength': '1024', # \u793a\u4f8b\u5927\u5c0f
\n 'getlastmodified': datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S GMT'),
\n 'creationdate': '2023-01-01T00:00:00Z'
\n }
\n })<\/p>\n
# \u5982\u679c\u6df1\u5ea6\u5927\u4e8e0，\u6dfb\u52a0\u5b50\u8d44\u6e90
\n if depth != '0':
\n # \u6a21\u62df\u5b50\u8d44\u6e90
\n for i in range(3):
\n child_path = f'{base_url}child{i}'
\n responses.append({
\n 'href': child_path,
\n 'status': 200,
\n 'message': 'OK',
\n 'props': {
\n 'displayname': f'child{i}',
\n 'resourcetype': '',
\n 'getcontentlength': '512',
\n 'getlastmodified': datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S GMT')
\n }
\n })<\/p>\n
# \u8fd4\u56de207\u54cd\u5e94
\n return multistatus.create_response(responses)<\/p>\n
# \u6279\u91cf\u5220\u9664\u5b9e\u73b0
\n@app.route('\/api\/resources\/batch-delete', methods=['POST'])
\ndef batch_delete():
\n """
\n \u6279\u91cf\u5220\u9664\u8d44\u6e90<\/p>\n
\u8fd4\u56de207 Multi-Status\u54cd\u5e94，\u5305\u542b\u6bcf\u4e2a\u8d44\u6e90\u7684\u5220\u9664\u7ed3\u679c
\n """<\/p>\n
# \u83b7\u53d6\u8981\u5220\u9664\u7684\u8d44\u6e90ID\u5217\u8868
\n resource_ids = request.json.get('resources', [])<\/p>\n
if not resource_ids:
\n return jsonify({'error': 'No resources specified'}), 400<\/p>\n
responses = []<\/p>\n
for resource_id in resource_ids:
\n try:
\n # \u5c1d\u8bd5\u5220\u9664\u8d44\u6e90
\n success = delete_resource(resource_id)<\/p>\n
if success:
\n responses.append({
\n 'href': f'\/api\/resources\/{resource_id}',
\n 'status': 200,
\n 'message': 'OK'
\n })
\n else:
\n responses.append({
\n 'href': f'\/api\/resources\/{resource_id}',
\n 'status': 404,
\n 'message': 'Not Found',
\n 'error': f'Resource {resource_id} not found'
\n })<\/p>\n
except Exception as e:
\n responses.append({
\n 'href': f'\/api\/resources\/{resource_id}',
\n 'status': 500,
\n 'message': 'Internal Server Error',
\n 'error': str(e)
\n })<\/p>\n
# \u8fd4\u56de207\u54cd\u5e94
\n return multistatus.create_response(responses)<\/p>\n
def delete_resource(resource_id):
\n """\u5220\u9664\u8d44\u6e90（\u6a21\u62df）"""
\n # \u5b9e\u9645\u4e2d\u4f1a\u4ece\u6570\u636e\u5e93\u5220\u9664
\n print(f"Deleting resource: {resource_id}")
\n return True # \u6a21\u62df\u6210\u529f<\/p>\n
# \u6279\u91cf\u521b\u5efa\u5b9e\u73b0
\n@app.route('\/api\/resources\/batch-create', methods=['POST'])
\ndef batch_create():
\n """
\n \u6279\u91cf\u521b\u5efa\u8d44\u6e90<\/p>\n
\u8fd4\u56de207 Multi-Status\u54cd\u5e94，\u5305\u542b\u6bcf\u4e2a\u8d44\u6e90\u7684\u521b\u5efa\u7ed3\u679c
\n """<\/p>\n
resources = request.json.get('resources', [])<\/p>\n
if not resources:
\n return jsonify({'error': 'No resources specified'}), 400<\/p>\n
responses = []<\/p>\n
for resource_data in resources:
\n try:
\n # \u9a8c\u8bc1\u8d44\u6e90\u6570\u636e
\n validation_result = validate_resource(resource_data)<\/p>\n
if not validation_result['valid']:
\n responses.append({
\n 'href': '\/api\/resources',
\n 'status': 400,
\n 'message': 'Bad Request',
\n 'error': validation_result['errors']
\n })
\n continue<\/p>\n
# \u521b\u5efa\u8d44\u6e90
\n created_resource = create_resource(resource_data)<\/p>\n
responses.append({
\n 'href': f'\/api\/resources\/{created_resource["id"]}',
\n 'status': 201,
\n 'message': 'Created',
\n 'props': created_resource
\n })<\/p>\n
except Exception as e:
\n responses.append({
\n 'href': '\/api\/resources',
\n 'status': 500,
\n 'message': 'Internal Server Error',
\n 'error': str(e)
\n })<\/p>\n
# \u8fd4\u56de207\u54cd\u5e94
\n return multistatus.create_response(responses)<\/p>\n
def validate_resource(data):
\n """\u9a8c\u8bc1\u8d44\u6e90\u6570\u636e（\u6a21\u62df）"""
\n errors = []<\/p>\n
if not data.get('name'):
\n errors.append('Name is required')<\/p>\n
return {
\n 'valid': len(errors) == 0,
\n 'errors': errors
\n }<\/p>\n
def create_resource(data):
\n """\u521b\u5efa\u8d44\u6e90（\u6a21\u62df）"""
\n import uuid
\n resource_id = str(uuid.uuid4())[:8]<\/p>\n
return {
\n 'id': resource_id,
\n 'name': data.get('name'),
\n 'created_at': datetime.utcnow().isoformat(),
\n 'status': 'active'
\n }<\/p>\n
# \u6279\u91cf\u66f4\u65b0\u5b9e\u73b0
\n@app.route('\/api\/resources\/batch-update', methods=['PATCH'])
\ndef batch_update():
\n """
\n \u6279\u91cf\u66f4\u65b0\u8d44\u6e90<\/p>\n
\u4f7f\u7528JSON Patch\u683c\u5f0f\u66f4\u65b0\u591a\u4e2a\u8d44\u6e90
\n """<\/p>\n
updates = request.json.get('updates', [])<\/p>\n
if not updates:
\n return jsonify({'error': 'No updates specified'}), 400<\/p>\n
responses = []<\/p>\n
for update in updates:
\n resource_id = update.get('id')
\n patch_operations = update.get('patch', [])<\/p>\n
if not resource_id or not patch_operations:
\n responses.append({
\n 'href': '\/api\/resources',
\n 'status': 400,
\n 'message': 'Bad Request',
\n 'error': 'Missing id or patch operations'
\n })
\n continue<\/p>\n
try:
\n # \u5e94\u7528JSON Patch
\n updated_resource = apply_patch(resource_id, patch_operations)<\/p>\n
responses.append({
\n 'href': f'\/api\/resources\/{resource_id}',
\n 'status': 200,
\n 'message': 'OK',
\n 'props': {
\n 'id': resource_id,
\n 'updated': True,
\n 'updated_at': datetime.utcnow().isoformat()
\n }
\n })<\/p>\n
except ResourceNotFoundError:
\n responses.append({
\n 'href': f'\/api\/resources\/{resource_id}',
\n 'status': 404,
\n 'message': 'Not Found',
\n 'error': f'Resource {resource_id} not found'
\n })<\/p>\n
except PatchError as e:
\n responses.append({
\n 'href': f'\/api\/resources\/{resource_id}',
\n 'status': 422,
\n 'message': 'Unprocessable Entity',
\n 'error': str(e)
\n })<\/p>\n
except Exception as e:
\n responses.append({
\n 'href': f'\/api\/resources\/{resource_id}',
\n 'status': 500,
\n 'message': 'Internal Server Error',
\n 'error': str(e)
\n })<\/p>\n
return multistatus.create_response(responses)<\/p>\n
class ResourceNotFoundError(Exception):
\n pass<\/p>\n
class PatchError(Exception):
\n pass<\/p>\n
def apply_patch(resource_id, patch_operations):
\n """\u5e94\u7528JSON Patch（\u6a21\u62df）"""
\n # \u5b9e\u9645\u4e2d\u4f1a\u66f4\u65b0\u6570\u636e\u5e93
\n print(f"Applying patch to {resource_id}: {patch_operations}")<\/p>\n
# \u6a21\u62df\u9a8c\u8bc1
\n for op in patch_operations:
\n if op.get('op') not in ['add', 'remove', 'replace', 'move', 'copy']:
\n raise PatchError(f'Invalid operation: {op.get("op")}')<\/p>\n
return True<\/p>\n
if __name__ == '__main__':
\n app.run(debug=True, port=5003)<\/p>\n
javascript<\/p>\n
\/\/ \u5ba2\u6237\u7aef\u5904\u7406207\u54cd\u5e94\u7684\u793a\u4f8b
\nclass MultiStatusResponseHandler {
\n \/**
\n * \u5904\u7406207 Multi-Status\u54cd\u5e94
\n *\/<\/p>\n
constructor() {
\n this.parser = new DOMParser();
\n }<\/p>\n
async handle207Response(response) {
\n \/\/ \u68c0\u67e5\u5185\u5bb9\u7c7b\u578b
\n const contentType = response.headers.get('Content-Type');
\n if (!contentType.includes('application\/xml')) {
\n throw new Error('Expected XML response for 207 status');
\n }<\/p>\n
\/\/ \u83b7\u53d6XML\u6587\u672c
\n const xmlText = await response.text();<\/p>\n
\/\/ \u89e3\u6790XML
\n const xmlDoc = this.parser.parseFromString(xmlText, 'application\/xml');<\/p>\n
\/\/ \u68c0\u67e5\u89e3\u6790\u9519\u8bef
\n const parserError = xmlDoc.querySelector('parsererror');
\n if (parserError) {
\n throw new Error('Failed to parse XML response');
\n }<\/p>\n
\/\/ \u63d0\u53d6\u6240\u6709\u54cd\u5e94
\n const responses = this.extractResponses(xmlDoc);<\/p>\n
\/\/ \u5206\u6790\u54cd\u5e94\u7ed3\u679c
\n const analysis = this.analyzeResponses(responses);<\/p>\n
return {
\n responses: responses,
\n analysis: analysis,
\n originalXml: xmlText,
\n success: analysis.successCount > 0 || analysis.partialSuccess
\n };
\n }<\/p>\n
extractResponses(xmlDoc) {
\n const responses = [];<\/p>\n
\/\/ \u67e5\u627e\u6240\u6709response\u5143\u7d20
\n const responseElements = xmlDoc.getElementsByTagNameNS('DAV:', 'response');<\/p>\n
for (const respElem of responseElements) {
\n const response = {
\n href: this.extractHref(respElem),
\n status: this.extractStatus(respElem),
\n properties: this.extractProperties(respElem),
\n error: this.extractError(respElem)
\n };<\/p>\n
responses.push(response);
\n }<\/p>\n
return responses;
\n }<\/p>\n
extractHref(responseElem) {
\n const hrefElem = responseElem.getElementsByTagNameNS('DAV:', 'href')[0];
\n return hrefElem ? hrefElem.textContent : null;
\n }<\/p>\n
extractStatus(responseElem) {
\n const statusElem = responseElem.getElementsByTagNameNS('DAV:', 'status')[0];
\n if (!statusElem) return null;<\/p>\n
const statusText = statusElem.textContent;
\n \/\/ \u683c\u5f0f: "HTTP\/1.1 200 OK"
\n const match = statusText.match(\/HTTP\\\\\/\\\\d\\\\.\\\\d\\\\s+(\\\\d+)\\\\s+(.+)\/);<\/p>\n
if (match) {
\n return {
\n code: parseInt(match[1], 10),
\n message: match[2],
\n raw: statusText
\n };
\n }<\/p>\n
return null;
\n }<\/p>\n
extractProperties(responseElem) {
\n const properties = {};<\/p>\n
\/\/ \u67e5\u627epropstat\u5143\u7d20
\n const propstatElems = responseElem.getElementsByTagNameNS('DAV:', 'propstat');<\/p>\n
for (const propstatElem of propstatElems) {
\n const propElem = propstatElem.getElementsByTagNameNS('DAV:', 'prop')[0];
\n if (!propElem) continue;<\/p>\n
\/\/ \u63d0\u53d6\u6240\u6709\u5c5e\u6027
\n for (const child of propElem.children) {
\n const tagName = child.tagName;
\n \/\/ \u79fb\u9664\u547d\u540d\u7a7a\u95f4
\n const simpleName = tagName.includes(':') ?
\n tagName.split(':')[1] : tagName;<\/p>\n
properties[simpleName] = child.textContent;
\n }
\n }<\/p>\n
return properties;
\n }<\/p>\n
extractError(responseElem) {
\n const errorElem = responseElem.getElementsByTagNameNS('DAV:', 'error')[0];
\n if (!errorElem) return null;<\/p>\n
const descElem = errorElem.getElementsByTagNameNS('DAV:', 'description')[0];
\n return descElem ? descElem.textContent : 'Unknown error';
\n }<\/p>\n
analyzeResponses(responses) {
\n const analysis = {
\n total: responses.length,
\n successCount: 0,
\n errorCount: 0,
\n partialSuccess: false,
\n statusCodes: {},
\n errors: []
\n };<\/p>\n
for (const resp of responses) {
\n if (resp.status) {
\n const code = resp.status.code;<\/p>\n
\/\/ \u7edf\u8ba1\u72b6\u6001\u7801
\n analysis.statusCodes[code] = (analysis.statusCodes[code] || 0) + 1;<\/p>\n
\/\/ \u5224\u65ad\u6210\u529f\/\u5931\u8d25
\n if (code >= 200 && code < 300) {
\n analysis.successCount++;
\n } else {
\n analysis.errorCount++;
\n if (resp.error) {
\n analysis.errors.push({
\n href: resp.href,
\n error: resp.error,
\n status: resp.status
\n });
\n }
\n }
\n }
\n }<\/p>\n
\/\/ \u68c0\u67e5\u662f\u5426\u90e8\u5206\u6210\u529f
\n analysis.partialSuccess = analysis.successCount > 0 &&
\n analysis.errorCount > 0;<\/p>\n
return analysis;
\n }<\/p>\n
\/\/ \u6279\u91cf\u64cd\u4f5c\u793a\u4f8b
\n async batchDelete(resourceIds) {
\n try {
\n const response = await fetch('\/api\/resources\/batch-delete', {
\n method: 'POST',
\n headers: {
\n 'Content-Type': 'application\/json'
\n },
\n body: JSON.stringify({
\n resources: resourceIds
\n })
\n });<\/p>\n
if (response.status === 207) {
\n const result = await this.handle207Response(response);<\/p>\n
\/\/ \u66f4\u65b0UI
\n this.updateUIAfterBatchDelete(result);<\/p>\n
return result;
\n } else {
\n throw new Error(`Unexpected status: ${response.status}`);
\n }<\/p>\n
} catch (error) {
\n console.error('Batch delete failed:', error);
\n throw error;
\n }
\n }<\/p>\n
updateUIAfterBatchDelete(result) {
\n const { analysis, responses } = result;<\/p>\n
\/\/ \u663e\u793a\u7ed3\u679c\u6458\u8981
\n const summary = `
\n Batch delete completed:
\n Total: ${analysis.total}
\n Successful: ${analysis.successCount}
\n Failed: ${analysis.errorCount}
\n ${analysis.partialSuccess ? '(Partial success)' : ''}
\n `;<\/p>\n
console.log(summary);<\/p>\n
\/\/ \u66f4\u65b0UI：\u79fb\u9664\u6210\u529f\u7684\u8d44\u6e90
\n for (const resp of responses) {
\n if (resp.status && resp.status.code === 200) {
\n \/\/ \u4eceUI\u4e2d\u79fb\u9664\u8be5\u8d44\u6e90
\n this.removeResourceFromUI(resp.href);
\n } else if (resp.error) {
\n \/\/ \u663e\u793a\u9519\u8bef
\n this.showResourceError(resp.href, resp.error);
\n }
\n }<\/p>\n
\/\/ \u663e\u793a\u901a\u77e5
\n if (analysis.partialSuccess) {
\n this.showPartialSuccessNotification(analysis);
\n } else if (analysis.successCount === analysis.total) {
\n this.showSuccessNotification('All resources deleted successfully');
\n } else {
\n this.showErrorNotification('Some resources failed to delete');
\n }
\n }<\/p>\n
removeResourceFromUI(resourceUrl) {
\n \/\/ \u4eceURL\u4e2d\u63d0\u53d6ID
\n const resourceId = resourceUrl.split('\/').pop();<\/p>\n
\/\/ \u4ece\u5217\u8868\u4e2d\u79fb\u9664
\n const element = document.querySelector(`[data-resource-id="${resourceId}"]`);
\n if (element) {
\n element.style.transition = 'opacity 0.3s';
\n element.style.opacity = '0';<\/p>\n
setTimeout(() => {
\n element.remove();<\/p>\n
\/\/ \u68c0\u67e5\u662f\u5426\u4e3a\u7a7a
\n this.checkEmptyState();
\n }, 300);
\n }
\n }<\/p>\n
showResourceError(resourceUrl, error) {
\n const resourceId = resourceUrl.split('\/').pop();
\n const element = document.querySelector(`[data-resource-id="${resourceId}"]`);<\/p>\n
if (element) {
\n const errorDiv = document.createElement('div');
\n errorDiv.className = 'error-message';
\n errorDiv.textContent = `Delete failed: ${error}`;<\/p>\n
element.appendChild(errorDiv);
\n }
\n }<\/p>\n
showPartialSuccessNotification(analysis) {
\n \/\/ \u663e\u793a\u90e8\u5206\u6210\u529f\u901a\u77e5
\n const notification = document.createElement('div');
\n notification.className = 'notification warning';
\n notification.innerHTML = `
\n <strong>Partial Success<\/strong>
\n <p>${analysis.successCount} of ${analysis.total} resources deleted successfully.<\/p>
\n <p>${analysis.errorCount} resources failed.<\/p>
\n `;<\/p>\n
this.showNotification(notification, 5000);
\n }<\/p>\n
showSuccessNotification(message) {
\n const notification = document.createElement('div');
\n notification.className = 'notification success';
\n notification.textContent = message;<\/p>\n
this.showNotification(notification, 3000);
\n }<\/p>\n
showErrorNotification(message) {
\n const notification = document.createElement('div');
\n notification.className = 'notification error';
\n notification.textContent = message;<\/p>\n
this.showNotification(notification, 5000);
\n }<\/p>\n
showNotification(element, duration) {
\n const container = document.getElementById('notification-container') ||
\n this.createNotificationContainer();<\/p>\n
container.appendChild(element);<\/p>\n
setTimeout(() => {
\n element.style.opacity = '0';
\n element.style.transition = 'opacity 0.5s';<\/p>\n
setTimeout(() => {
\n element.remove();
\n }, 500);
\n }, duration);
\n }<\/p>\n
createNotificationContainer() {
\n const container = document.createElement('div');
\n container.id = 'notification-container';
\n container.style.cssText = `
\n position: fixed;
\n top: 20px;
\n right: 20px;
\n z-index: 1000;
\n `;<\/p>\n
document.body.appendChild(container);
\n return container;
\n }<\/p>\n
checkEmptyState() {
\n const resourceList = document.getElementById('resource-list');
\n if (resourceList && resourceList.children.length === 0) {
\n resourceList.innerHTML = `
\n <div class="empty-state">
\n <h3>No resources found<\/h3>
\n <p>All resources have been deleted.<\/p>
\n <\/div>
\n `;
\n }
\n }<\/p>\n
\/\/ WebDAV PROPFIND\u793a\u4f8b
\n async webdavPropfind(url, depth = '1') {
\n try {
\n const response = await fetch(url, {
\n method: 'PROPFIND',
\n headers: {
\n 'Depth': depth,
\n 'Content-Type': 'application\/xml'
\n }
\n });<\/p>\n
if (response.status === 207) {
\n const result = await this.handle207Response(response);<\/p>\n
\/\/ \u5904\u7406WebDAV\u54cd\u5e94
\n this.processWebDAVResponse(result);<\/p>\n
return result;
\n } else {
\n throw new Error(`Unexpected status: ${response.status}`);
\n }<\/p>\n
} catch (error) {
\n console.error('PROPFIND failed:', error);
\n throw error;
\n }
\n }<\/p>\n
processWebDAVResponse(result) {
\n \/\/ \u6784\u5efa\u6587\u4ef6\/\u6587\u4ef6\u5939\u6811
\n const tree = this.buildResourceTree(result.responses);<\/p>\n
\/\/ \u663e\u793a\u8d44\u6e90\u5217\u8868
\n this.displayResourceTree(tree);<\/p>\n
return tree;
\n }<\/p>\n
buildResourceTree(responses) {
\n const tree = {
\n '\/': { name: 'Root', type: 'collection', children: [] }
\n };<\/p>\n
for (const resp of responses) {
\n const href = resp.href;
\n const props = resp.properties;<\/p>\n
\/\/ \u89e3\u6790\u8def\u5f84
\n const path = href.replace(\/^\\\\\/dav\\\\\/\/, '\/');
\n const parts = path.split('\/').filter(p => p);<\/p>\n
\/\/ \u6784\u5efa\u6811\u8282\u70b9
\n let current = tree['\/'];<\/p>\n
for (let i = 0; i < parts.length; i++) {
\n const part = parts[i];
\n const isLast = i === parts.length – 1;
\n const fullPath = '\/' + parts.slice(0, i + 1).join('\/');<\/p>\n
if (!tree[fullPath]) {
\n tree[fullPath] = {
\n name: part,
\n type: props.resourcetype ? 'collection' : 'resource',
\n children: [],
\n properties: isLast ? props : {}
\n };<\/p>\n
current.children.push(tree[fullPath]);
\n }<\/p>\n
current = tree[fullPath];
\n }
\n }<\/p>\n
return tree;
\n }<\/p>\n
displayResourceTree(tree) {
\n const container = document.getElementById('dav-explorer');
\n if (!container) return;<\/p>\n
container.innerHTML = this.renderTree(tree['\/']);
\n }<\/p>\n
renderTree(node, depth = 0) {
\n const indent = ' '.repeat(depth);
\n let html = `${indent}<div class="dav-item" data-type="${node.type}">`;<\/p>\n
\/\/ \u56fe\u6807
\n const icon = node.type === 'collection' ? '📁' : '📄';
\n html += `${icon} ${node.name}`;<\/p>\n
\/\/ \u663e\u793a\u5c5e\u6027（\u5982\u679c\u5c55\u5f00）
\n if (node.properties && Object.keys(node.properties).length > 0) {
\n html += `<div class="dav-properties" style="margin-left: 20px; font-size: 0.9em; color: #666;">`;
\n for (const [key, value] of Object.entries(node.properties)) {
\n if (value && value.trim()) {
\n html += `<div>${key}: ${value}<\/div>`;
\n }
\n }
\n html += `<\/div>`;
\n }<\/p>\n
\/\/ \u5b50\u8282\u70b9
\n if (node.children.length > 0) {
\n html += `<div class="dav-children">`;
\n for (const child of node.children) {
\n html += this.renderTree(child, depth + 1);
\n }
\n html += `<\/div>`;
\n }<\/p>\n
html += `<\/div>`;
\n return html;
\n }
\n}<\/p>\n
\/\/ \u4f7f\u7528\u793a\u4f8b
\ndocument.addEventListener('DOMContentLoaded', () => {
\n const handler = new MultiStatusResponseHandler();<\/p>\n
\/\/ \u6279\u91cf\u5220\u9664\u6309\u94ae
\n document.getElementById('batch-delete-btn').addEventListener('click', async () => {
\n \/\/ \u83b7\u53d6\u9009\u4e2d\u7684\u8d44\u6e90ID
\n const selectedIds = Array.from(
\n document.querySelectorAll('input[name="resource"]:checked')
\n ).map(input => input.value);<\/p>\n
if (selectedIds.length === 0) {
\n alert('Please select at least one resource');
\n return;
\n }<\/p>\n
if (!confirm(`Delete ${selectedIds.length} resources?`)) {
\n return;
\n }<\/p>\n
try {
\n await handler.batchDelete(selectedIds);
\n } catch (error) {
\n console.error('Batch delete failed:', error);
\n alert('Failed to delete resources');
\n }
\n });<\/p>\n
\/\/ WebDAV\u6d4f\u89c8\u5668
\n document.getElementById('load-dav-btn').addEventListener('click', async () => {
\n const url = document.getElementById('dav-url').value;<\/p>\n
if (!url) {
\n alert('Please enter a WebDAV URL');
\n return;
\n }<\/p>\n
try {
\n await handler.webdavPropfind(url);
\n } catch (error) {
\n console.error('Failed to load WebDAV:', error);
\n alert('Failed to load WebDAV contents');
\n }
\n });<\/p>\n
\/\/ \u6279\u91cf\u521b\u5efa\u793a\u4f8b
\n document.getElementById('batch-create-form').addEventListener('submit', async (e) => {
\n e.preventDefault();<\/p>\n
const resources = [];
\n const resourceInputs = document.querySelectorAll('.resource-input');<\/p>\n
resourceInputs.forEach(input => {
\n if (input.value.trim()) {
\n resources.push({
\n name: input.value.trim(),
\n type: input.dataset.type || 'default'
\n });
\n }
\n });<\/p>\n
if (resources.length === 0) {
\n alert('Please enter at least one resource');
\n return;
\n }<\/p>\n
try {
\n const response = await fetch('\/api\/resources\/batch-create', {
\n method: 'POST',
\n headers: {
\n 'Content-Type': 'application\/json'
\n },
\n body: JSON.stringify({ resources })
\n });<\/p>\n
if (response.status === 207) {
\n const result = await handler.handle207Response(response);<\/p>\n
\/\/ \u663e\u793a\u7ed3\u679c
\n const successCount = result.analysis.successCount;
\n const errorCount = result.analysis.errorCount;<\/p>\n
alert(`Created ${successCount} resources successfully. ${errorCount} failed.`);<\/p>\n
\/\/ \u5237\u65b0\u5217\u8868
\n location.reload();
\n } else {
\n throw new Error(`Unexpected status: ${response.status}`);
\n }<\/p>\n
} catch (error) {
\n console.error('Batch create failed:', error);
\n alert('Failed to create resources');
\n }
\n });
\n});<\/p>\n
\u6839\u636eRFC 5842（WebDAV\u7ed1\u5b9a\u6269\u5c55）\u7b2c7.1\u8282，208 Already Reported\u72b6\u6001\u7801\u7684\u5b9a\u4e49\u5982\u4e0b：<\/p>\n
208 (Already Reported)\u72b6\u6001\u7801\u5728\u54cd\u5e94WebDAV PROPFIND\u8bf7\u6c42\u65f6\u4f7f\u7528，\u7528\u4e8e\u907f\u514d\u91cd\u590d\u679a\u4e3e\u7ed1\u5b9a\u96c6\u5408\u7684\u5185\u90e8\u6210\u5458\u3002\u5f53\u5ba2\u6237\u7aef\u8bf7\u6c42\u4e00\u4e2a\u7ed1\u5b9a\u7684\u96c6\u5408（\u5373\u4e00\u4e2a\u8d44\u6e90\u6709\u591a\u4e2aURI）\u65f6，\u670d\u52a1\u5668\u53ef\u4ee5\u4f7f\u7528208\u54cd\u5e94\u6765\u6307\u793a\u8be5\u8d44\u6e90\u5df2\u7ecf\u5728\u524d\u9762\u7684\u54cd\u5e94\u4e2d\u62a5\u544a\u8fc7，\u4ece\u800c\u907f\u514d\u5728\u54cd\u5e94\u4e2d\u591a\u6b21\u8fd4\u56de\u540c\u4e00\u4e2a\u8d44\u6e90\u3002<\/p>\n
\u907f\u514d\u91cd\u590d\u679a\u4e3e：\u9632\u6b62\u5728WebDAV\u7ed1\u5b9a\u96c6\u5408\u4e2d\u591a\u6b21\u62a5\u544a\u540c\u4e00\u8d44\u6e90<\/p>\n<\/li>\n
\u5185\u90e8\u4f7f\u7528：\u5728207 Multi-Status\u54cd\u5e94\u5185\u90e8\u4f7f\u7528<\/p>\n<\/li>\n
WebDAV\u7ed1\u5b9a：\u4e13\u95e8\u7528\u4e8e\u5904\u7406WebDAV\u7ed1\u5b9a\u7684\u573a\u666f<\/p>\n<\/li>\n
\u4f18\u5316\u6027\u80fd：\u51cf\u5c11\u54cd\u5e94\u5927\u5c0f，\u907f\u514d\u5ba2\u6237\u7aef\u5904\u7406\u91cd\u590d\u8d44\u6e90<\/p>\n<\/li>\n
python<\/p>\n
# 208 Already Reported\u670d\u52a1\u5668\u5b9e\u73b0
\nfrom flask import Flask, request, Response
\nimport xml.etree.ElementTree as ET
\nfrom xml.dom import minidom<\/p>\n
app = Flask(__name__)<\/p>\n
class AlreadyReportedResponse:
\n """208 Already Reported\u54cd\u5e94\u751f\u6210\u5668"""<\/p>\n
DAV_NAMESPACE = 'DAV:'
\n DAV_PREFIX = 'd'<\/p>\n
def __init__(self):
\n ET.register_namespace(self.DAV_PREFIX, self.DAV_NAMESPACE)<\/p>\n
def create_propfind_response(self, bindings):
\n """
\n \u521b\u5efaPROPFIND\u54cd\u5e94，\u4f7f\u7528208\u907f\u514d\u91cd\u590d<\/p>\n
Args:
\n bindings: \u7ed1\u5b9a\u5217\u8868，\u6bcf\u4e2a\u5143\u7d20\u662f\u4e00\u4e2a\u5b57\u5178，\u5305\u542b：
\n – href: \u8d44\u6e90URI
\n – bindings: \u8be5\u8d44\u6e90\u7684\u6240\u6709\u7ed1\u5b9aURI\u5217\u8868
\n – props: \u8d44\u6e90\u5c5e\u6027<\/p>\n
Returns:
\n 207 Multi-Status\u54cd\u5e94，\u5185\u90e8\u53ef\u80fd\u5305\u542b208\u54cd\u5e94
\n """
\n root = ET.Element(f'{{{self.DAV_NAMESPACE}}}multistatus')<\/p>\n
# \u7528\u4e8e\u8ddf\u8e2a\u5df2\u7ecf\u62a5\u544a\u8fc7\u7684\u8d44\u6e90
\n reported_resources = set()<\/p>\n
for binding in bindings:
\n # \u83b7\u53d6\u8d44\u6e90\u7684\u89c4\u8303URI（\u4f8b\u5982\u7b2c\u4e00\u4e2a\u7ed1\u5b9a）
\n canonical_href = binding['bindings'][0]<\/p>\n
# \u5982\u679c\u5df2\u7ecf\u62a5\u544a\u8fc7，\u5219\u8df3\u8fc7
\n if canonical_href in reported_resources:
\n continue<\/p>\n
# \u6807\u8bb0\u4e3a\u5df2\u62a5\u544a
\n reported_resources.add(canonical_href)<\/p>\n
# \u4e3a\u89c4\u8303URI\u521b\u5efa\u54cd\u5e94
\n self._add_response(root, canonical_href, binding['props'], 200)<\/p>\n
# \u4e3a\u5176\u4ed6\u7ed1\u5b9aURI\u521b\u5efa208\u54cd\u5e94
\n for alt_href in binding['bindings'][1:]:
\n self._add_response(root, alt_href, {}, 208)<\/p>\n
# \u8f6c\u6362\u4e3aXML
\n xml_str = self._prettify_xml(root)<\/p>\n
return Response(
\n xml_str,
\n status=207,
\n content_type='application\/xml; charset="utf-8"'
\n )<\/p>\n
def _add_response(self, parent, href, props, status_code):
\n """\u6dfb\u52a0\u5355\u4e2aresponse\u5143\u7d20\u5230\u7236\u5143\u7d20"""
\n response_elem = ET.SubElement(parent, f'{{{self.DAV_NAMESPACE}}}response')<\/p>\n
# href
\n href_elem = ET.SubElement(response_elem, f'{{{self.DAV_NAMESPACE}}}href')
\n href_elem.text = href<\/p>\n
# propstat
\n if props or status_code != 208:
\n propstat_elem = ET.SubElement(response_elem, f'{{{self.DAV_NAMESPACE}}}propstat')<\/p>\n
# prop
\n prop_elem = ET.SubElement(propstat_elem, f'{{{self.DAV_NAMESPACE}}}prop')
\n for key, value in props.items():
\n prop_item = ET.SubElement(prop_elem, f'{{{self.DAV_NAMESPACE}}}{key}')
\n prop_item.text = value<\/p>\n
# status
\n status_elem = ET.SubElement(propstat_elem, f'{{{self.DAV_NAMESPACE}}}status')
\n if status_code == 200:
\n status_elem.text = 'HTTP\/1.1 200 OK'
\n elif status_code == 208:
\n status_elem.text = 'HTTP\/1.1 208 Already Reported'<\/p>\n
# \u5bf9\u4e8e208，\u4e5f\u53ef\u4ee5\u76f4\u63a5\u4f7f\u7528status\u5143\u7d20（\u4e0d\u5728propstat\u5185）
\n else:
\n status_elem = ET.SubElement(response_elem, f'{{{self.DAV_NAMESPACE}}}status')
\n status_elem.text = 'HTTP\/1.1 208 Already Reported'<\/p>\n
def _prettify_xml(self, elem):
\n """\u683c\u5f0f\u5316XML"""
\n rough_string = ET.tostring(elem, 'utf-8')
\n parsed = minidom.parseString(rough_string)
\n return parsed.toprettyxml(indent=' ')<\/p>\n
# \u6a21\u62df\u7ed1\u5b9a\u96c6\u5408\u7684\u6570\u636e
\ndef get_binding_data():
\n """\u83b7\u53d6\u7ed1\u5b9a\u96c6\u5408\u6570\u636e（\u6a21\u62df）"""<\/p>\n
# \u5047\u8bbe\u6709\u4e24\u4e2a\u8d44\u6e90，\u6bcf\u4e2a\u8d44\u6e90\u6709\u591a\u4e2a\u7ed1\u5b9a（URI）
\n return [
\n {
\n 'bindings': [
\n '\/dav\/files\/doc1', # \u89c4\u8303URI
\n '\/dav\/aliases\/doc1-alias1', # \u522b\u540d1
\n '\/dav\/aliases\/doc1-alias2' # \u522b\u540d2
\n ],
\n 'props': {
\n 'displayname': 'document1.pdf',
\n 'getcontentlength': '1048576',
\n 'getcontenttype': 'application\/pdf',
\n 'getlastmodified': 'Wed, 25 Jan 2023 10:30:00 GMT'
\n }
\n },
\n {
\n 'bindings': [
\n '\/dav\/files\/doc2',
\n '\/dav\/aliases\/doc2-alias1'
\n ],
\n 'props': {
\n 'displayname': 'document2.txt',
\n 'getcontentlength': '2048',
\n 'getcontenttype': 'text\/plain',
\n 'getlastmodified': 'Wed, 25 Jan 2023 11:45:00 GMT'
\n }
\n },
\n {
\n 'bindings': [
\n '\/dav\/files\/doc3'
\n ],
\n 'props': {
\n 'displayname': 'document3.jpg',
\n 'getcontentlength': '524288',
\n 'getcontenttype': 'image\/jpeg',
\n 'getlastmodified': 'Wed, 25 Jan 2023 12:00:00 GMT'
\n }
\n }
\n ]<\/p>\n
# WebDAV PROPFIND\u7aef\u70b9
\n@app.route('\/dav\/<path:path>', methods=['PROPFIND'])
\ndef webdav_propfind_with_bindings(path):
\n """\u5904\u7406PROPFIND\u8bf7\u6c42，\u652f\u6301\u7ed1\u5b9a\u96c6\u5408"""<\/p>\n
# \u83b7\u53d6\u7ed1\u5b9a\u6570\u636e
\n bindings = get_binding_data()<\/p>\n
# \u521b\u5efa\u54cd\u5e94
\n response_builder = AlreadyReportedResponse()
\n response = response_builder.create_propfind_response(bindings)<\/p>\n
return response<\/p>\n
if __name__ == '__main__':
\n app.run(debug=True, port=5004)<\/p>\n
javascript<\/p>\n
\/\/ \u5ba2\u6237\u7aef\u5904\u7406208\u54cd\u5e94\u7684\u793a\u4f8b
\nclass AlreadyReportedHandler {
\n \/**
\n * \u5904\u7406WebDAV\u54cd\u5e94\u4e2d\u7684208 Already Reported\u72b6\u6001
\n *\/<\/p>\n
constructor() {
\n this.parser = new DOMParser();
\n }<\/p>\n
async processPropfindResponse(url) {
\n try {
\n const response = await fetch(url, {
\n method: 'PROPFIND',
\n headers: {
\n 'Depth': '1',
\n 'Content-Type': 'application\/xml'
\n }
\n });<\/p>\n
if (response.status === 207) {
\n const xmlText = await response.text();
\n const xmlDoc = this.parser.parseFromString(xmlText, 'application\/xml');<\/p>\n
\/\/ \u63d0\u53d6\u6240\u6709\u54cd\u5e94
\n const responses = this.extractResponses(xmlDoc);<\/p>\n
\/\/ \u8fc7\u6ee4\u6389208\u54cd\u5e94（\u5b83\u4eec\u53ea\u662f\u6307\u793a\u91cd\u590d，\u4e0d\u5305\u542b\u65b0\u4fe1\u606f）
\n const uniqueResources = this.filterDuplicateResources(responses);<\/p>\n
\/\/ \u663e\u793a\u8d44\u6e90
\n this.displayResources(uniqueResources);<\/p>\n
return uniqueResources;
\n } else {
\n throw new Error(`Unexpected status: ${response.status}`);
\n }
\n } catch (error) {
\n console.error('PROPFIND failed:', error);
\n throw error;
\n }
\n }<\/p>\n
extractResponses(xmlDoc) {
\n const responses = [];
\n const responseElements = xmlDoc.getElementsByTagNameNS('DAV:', 'response');<\/p>\n
for (const respElem of responseElements) {
\n const href = this.getHref(respElem);
\n const status = this.getStatus(respElem);
\n const props = this.getProperties(respElem);<\/p>\n
responses.push({
\n href: href,
\n status: status,
\n properties: props
\n });
\n }<\/p>\n
return responses;
\n }<\/p>\n
getHref(responseElem) {
\n const hrefElem = responseElem.getElementsByTagNameNS('DAV:', 'href')[0];
\n return hrefElem ? hrefElem.textContent : null;
\n }<\/p>\n
getStatus(responseElem) {
\n \/\/ \u67e5\u627estatus\u5143\u7d20
\n const statusElems = responseElem.getElementsByTagNameNS('DAV:', 'status');
\n if (statusElems.length === 0) return null;<\/p>\n
const statusText = statusElems[0].textContent;
\n const match = statusText.match(\/HTTP\\\\\/\\\\d\\\\.\\\\d\\\\s+(\\\\d+)\\\\s+(.+)\/);<\/p>\n
if (match) {
\n return {
\n code: parseInt(match[1], 10),
\n message: match[2]
\n };
\n }<\/p>\n
return null;
\n }<\/p>\n
getProperties(responseElem) {
\n const properties = {};
\n const propstatElems = responseElem.getElementsByTagNameNS('DAV:', 'propstat');<\/p>\n
for (const propstatElem of propstatElems) {
\n const propElem = propstatElem.getElementsByTagNameNS('DAV:', 'prop')[0];
\n if (!propElem) continue;<\/p>\n
for (const child of propElem.children) {
\n const tagName = child.tagName;
\n const simpleName = tagName.includes(':') ?
\n tagName.split(':')[1] : tagName;<\/p>\n
properties[simpleName] = child.textContent;
\n }
\n }<\/p>\n
return properties;
\n }<\/p>\n
filterDuplicateResources(responses) {
\n \/\/ \u7528\u4e8e\u8ddf\u8e2a\u5df2\u7ecf\u770b\u5230\u7684\u8d44\u6e90（\u57fa\u4e8e\u5c5e\u6027）
\n const seenResources = new Map();
\n const uniqueResources = [];<\/p>\n
for (const resp of responses) {
\n \/\/ \u8df3\u8fc7208\u54cd\u5e94
\n if (resp.status && resp.status.code === 208) {
\n console.log(`Skipping already reported resource: ${resp.href}`);
\n continue;
\n }<\/p>\n
\/\/ \u751f\u6210\u8d44\u6e90\u6807\u8bc6\u7b26（\u57fa\u4e8e\u5c5e\u6027，\u800c\u4e0d\u662fhref）
\n const resourceId = this.generateResourceId(resp.properties);<\/p>\n
if (resourceId && seenResources.has(resourceId)) {
\n console.log(`Duplicate resource detected: ${resp.href}`);
\n \/\/ \u53ef\u4ee5\u9009\u62e9\u4fdd\u7559\u4e00\u4e2a（\u4f8b\u5982，\u89c4\u8303URI）
\n continue;
\n }<\/p>\n
if (resourceId) {
\n seenResources.set(resourceId, resp);
\n }<\/p>\n
uniqueResources.push(resp);
\n }<\/p>\n
console.log(`Found ${uniqueResources.length} unique resources (${responses.length – uniqueResources.length} duplicates skipped)`);
\n return uniqueResources;
\n }<\/p>\n
generateResourceId(properties) {
\n \/\/ \u4f7f\u7528\u5173\u952e\u5c5e\u6027\u751f\u6210\u8d44\u6e90ID
\n \/\/ \u5728\u5b9e\u9645\u5e94\u7528\u4e2d，\u53ef\u80fd\u9700\u8981\u6839\u636e\u670d\u52a1\u5668\u884c\u4e3a\u8c03\u6574
\n const keys = ['displayname', 'getcontentlength', 'getcontenttype', 'getlastmodified'];
\n const values = keys.map(key => properties[key] || '').join('|');<\/p>\n
if (values.trim()) {
\n return btoa(values); \/\/ \u7b80\u5355\u7f16\u7801
\n }<\/p>\n
return null;
\n }<\/p>\n
displayResources(resources) {
\n const container = document.getElementById('dav-resources');
\n if (!container) return;<\/p>\n
container.innerHTML = '';<\/p>\n
resources.forEach(resource => {
\n const resourceElem = document.createElement('div');
\n resourceElem.className = 'dav-resource';<\/p>\n
const name = resource.properties.displayname || resource.href.split('\/').pop();
\n const type = resource.properties.getcontenttype || 'unknown';
\n const size = resource.properties.getcontentlength || '0';<\/p>\n
resourceElem.innerHTML = `
\n <h3>${name}<\/h3>
\n <p><strong>URI:<\/strong> ${resource.href}<\/p>
\n <p><strong>Type:<\/strong> ${type}<\/p>
\n <p><strong>Size:<\/strong> ${this.formatBytes(size)}<\/p>
\n <p><strong>Modified:<\/strong> ${resource.properties.getlastmodified || 'unknown'}<\/p>
\n `;<\/p>\n
container.appendChild(resourceElem);
\n });
\n }<\/p>\n
formatBytes(bytes) {
\n bytes = parseInt(bytes, 10);
\n if (bytes === 0) return '0 Bytes';<\/p>\n
const k = 1024;
\n const sizes = ['Bytes', 'KB', 'MB', 'GB'];
\n const i = Math.floor(Math.log(bytes) \/ Math.log(k));<\/p>\n
return parseFloat((bytes \/ Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
\n }
\n}<\/p>\n
\/\/ \u4f7f\u7528\u793a\u4f8b
\ndocument.addEventListener('DOMContentLoaded', () => {
\n const handler = new AlreadyReportedHandler();<\/p>\n
document.getElementById('load-dav-bindings').addEventListener('click', async () => {
\n const url = document.getElementById('dav-url').value;<\/p>\n
if (!url) {
\n alert('Please enter a WebDAV URL');
\n return;
\n }<\/p>\n
try {
\n await handler.processPropfindResponse(url);
\n } catch (error) {
\n console.error('Failed to load DAV bindings:', error);
\n alert('Failed to load resources');
\n }
\n });
\n});<\/p>\n
\u6839\u636eRFC 3229（\u589e\u91cf\u7f16\u7801）\u7b2c10.4.1\u8282，226 IM Used\u72b6\u6001\u7801\u7684\u5b9a\u4e49\u5982\u4e0b：<\/p>\n
226 (IM Used)\u72b6\u6001\u7801\u8868\u793a\u670d\u52a1\u5668\u5df2\u6210\u529f\u5b8c\u6210\u5bf9\u8d44\u6e90\u7684\u8bf7\u6c42，\u5e76\u4e14\u54cd\u5e94\u662f\u5b9e\u4f8b\u64cd\u4f5c（instance manipulation）\u5e94\u7528\u4e8e\u5f53\u524d\u5b9e\u4f8b\u540e\u7684\u8868\u793a\u3002\u5b9e\u4f8b\u64cd\u4f5c\u7684\u793a\u4f8b\u5305\u62ec\u5dee\u5206\u7f16\u7801（delta encoding）\u3001\u538b\u7f29\u6216\u8f6c\u6362\u3002<\/p>\n
\u5b9e\u4f8b\u64cd\u4f5c\u5e94\u7528：\u54cd\u5e94\u4f53\u662f\u7ecf\u8fc7\u8f6c\u6362\u6216\u7f16\u7801\u7684<\/p>\n<\/li>\n
\u589e\u91cf\u7f16\u7801：\u5e38\u7528\u4e8e\u652f\u6301RFC 3229\u7684\u589e\u91cf\u7f16\u7801<\/p>\n<\/li>\n
\u5e26\u5bbd\u4f18\u5316：\u901a\u8fc7\u53ea\u53d1\u9001\u53d8\u5316\u90e8\u5206\u6765\u51cf\u5c11\u6570\u636e\u4f20\u8f93<\/p>\n<\/li>\n
\u6761\u4ef6\u8bf7\u6c42：\u901a\u5e38\u4e0eDelta\u7f16\u7801\u548cIf-None-Match\u7b49\u5934\u90e8\u914d\u5408\u4f7f\u7528<\/p>\n<\/li>\n
python<\/p>\n
# 226 IM Used\u670d\u52a1\u5668\u5b9e\u73b0
\nfrom flask import Flask, request, Response
\nimport json
\nimport hashlib
\nfrom datetime import datetime
\nfrom typing import Dict, Any, Optional<\/p>\n
app = Flask(__name__)<\/p>\n
class DeltaEncoder:
\n """\u589e\u91cf\u7f16\u7801\u5668，\u7528\u4e8e\u751f\u6210226\u54cd\u5e94"""<\/p>\n
def __init__(self):
\n self.resource_versions = {}<\/p>\n
def get_delta_response(self, resource_id: str, client_etag: Optional[str]) -> Dict[str, Any]:
\n """
\n \u83b7\u53d6\u589e\u91cf\u54cd\u5e94<\/p>\n
Args:
\n resource_id: \u8d44\u6e90ID
\n client_etag: \u5ba2\u6237\u7aef\u5f53\u524d\u7248\u672c\u7684ETag<\/p>\n
Returns:
\n \u54cd\u5e94\u6570\u636e\u548c\u72b6\u6001\u7801
\n """
\n # \u83b7\u53d6\u5f53\u524d\u8d44\u6e90\u72b6\u6001
\n current_version = self.get_current_version(resource_id)
\n current_etag = self.generate_etag(current_version)<\/p>\n
# \u5982\u679c\u5ba2\u6237\u7aef\u6ca1\u6709\u63d0\u4f9bETag，\u8fd4\u56de\u5b8c\u6574\u8d44\u6e90
\n if not client_etag:
\n return {
\n 'status': 200,
\n 'data': current_version,
\n 'headers': {
\n 'ETag': current_etag,
\n 'IM': None # \u6ca1\u6709\u4f7f\u7528\u5b9e\u4f8b\u64cd\u4f5c
\n }
\n }<\/p>\n
# \u5982\u679c\u5ba2\u6237\u7aefETag\u4e0e\u5f53\u524dETag\u76f8\u540c，\u8fd4\u56de304
\n if client_etag == current_etag:
\n return {
\n 'status': 304,
\n 'data': None,
\n 'headers': {'ETag': current_etag}
\n }<\/p>\n
# \u67e5\u627e\u5ba2\u6237\u7aef\u7248\u672c
\n client_version = self.find_version_by_etag(resource_id, client_etag)<\/p>\n
if client_version:
\n # \u8ba1\u7b97\u589e\u91cf
\n delta = self.compute_delta(client_version, current_version)<\/p>\n
# \u5982\u679c\u589e\u91cf\u6bd4\u5b8c\u6574\u8d44\u6e90\u5c0f，\u8fd4\u56de226
\n if self.is_delta_smaller(delta, current_version):
\n return {
\n 'status': 226,
\n 'data': delta,
\n 'headers': {
\n 'ETag': current_etag,
\n 'IM': 'delta', # \u4f7f\u7528\u4e86\u589e\u91cf\u7f16\u7801
\n 'Delta-Base': client_etag # \u57fa\u4e8e\u54ea\u4e2a\u7248\u672c
\n }
\n }<\/p>\n
# \u56de\u9000\u5230\u5b8c\u6574\u8d44\u6e90
\n return {
\n 'status': 200,
\n 'data': current_version,
\n 'headers': {
\n 'ETag': current_etag,
\n 'IM': None
\n }
\n }<\/p>\n
def get_current_version(self, resource_id: str) -> Dict[str, Any]:
\n """\u83b7\u53d6\u8d44\u6e90\u7684\u5f53\u524d\u7248\u672c"""
\n # \u6a21\u62df\u6570\u636e – \u5b9e\u9645\u4e2d\u4ece\u6570\u636e\u5e93\u83b7\u53d6
\n if resource_id not in self.resource_versions:
\n self.resource_versions[resource_id] = {
\n 'versions': [],
\n 'current_index': -1
\n }<\/p>\n
resource = self.resource_versions[resource_id]<\/p>\n
# \u5982\u679c\u6ca1\u6709\u7248\u672c，\u521b\u5efa\u521d\u59cb\u7248\u672c
\n if resource['current_index'] < 0:
\n initial_version = self.create_initial_version(resource_id)
\n resource['versions'].append({
\n 'data': initial_version,
\n 'etag': self.generate_etag(initial_version),
\n 'timestamp': datetime.utcnow().isoformat()
\n })
\n resource['current_index'] = 0<\/p>\n
return resource['versions'][resource['current_index']]['data']<\/p>\n
def create_initial_version(self, resource_id: str) -> Dict[str, Any]:
\n """\u521b\u5efa\u521d\u59cb\u7248\u672c"""
\n return {
\n 'id': resource_id,
\n 'title': f'Resource {resource_id}',
\n 'content': 'Initial content',
\n 'version': 1,
\n 'created_at': datetime.utcnow().isoformat(),
\n 'updated_at': datetime.utcnow().isoformat()
\n }<\/p>\n
def update_resource(self, resource_id: str, updates: Dict[str, Any]) -> Dict[str, Any]:
\n """\u66f4\u65b0\u8d44\u6e90，\u521b\u5efa\u65b0\u7248\u672c"""
\n if resource_id not in self.resource_versions:
\n self.get_current_version(resource_id) # \u521d\u59cb\u5316<\/p>\n
resource = self.resource_versions[resource_id]
\n current = resource['versions'][resource['current_index']]['data'].copy()<\/p>\n
# \u5e94\u7528\u66f4\u65b0
\n current.update(updates)
\n current['version'] += 1
\n current['updated_at'] = datetime.utcnow().isoformat()<\/p>\n
# \u4fdd\u5b58\u65b0\u7248\u672c
\n new_version = {
\n 'data': current,
\n 'etag': self.generate_etag(current),
\n 'timestamp': datetime.utcnow().isoformat()
\n }<\/p>\n
resource['versions'].append(new_version)
\n resource['current_index'] += 1<\/p>\n
# \u9650\u5236\u7248\u672c\u5386\u53f2\u957f\u5ea6
\n if len(resource['versions']) > 10:
\n resource['versions'] = resource['versions'][-10:]
\n resource['current_index'] = min(resource['current_index'], 9)<\/p>\n
return current<\/p>\n
def generate_etag(self, data: Dict[str, Any]) -> str:
\n """\u751f\u6210ETag"""
\n content = json.dumps(data, sort_keys=True)
\n return f'"{hashlib.md5(content.encode()).hexdigest()}"'<\/p>\n
def find_version_by_etag(self, resource_id: str, etag: str) -> Optional[Dict[str, Any]]:
\n """\u6839\u636eETag\u67e5\u627e\u7248\u672c"""
\n if resource_id not in self.resource_versions:
\n return None<\/p>\n
for version in self.resource_versions[resource_id]['versions']:
\n if version['etag'] == etag:
\n return version['data']<\/p>\n
return None<\/p>\n
def compute_delta(self, old_version: Dict[str, Any], new_version: Dict[str, Any]) -> Dict[str, Any]:
\n """\u8ba1\u7b97\u4e24\u4e2a\u7248\u672c\u4e4b\u95f4\u7684\u5dee\u5f02"""
\n delta = {
\n 'operation': 'patch',
\n 'from_version': old_version.get('version'),
\n 'to_version': new_version.get('version'),
\n 'changes': []
\n }<\/p>\n
# \u7b80\u5355\u6bd4\u8f83：\u627e\u51fa\u53d8\u5316\u7684\u5b57\u6bb5
\n all_keys = set(old_version.keys()) | set(new_version.keys())<\/p>\n
for key in all_keys:
\n old_value = old_version.get(key)
\n new_value = new_version.get(key)<\/p>\n
if old_value != new_value:
\n delta['changes'].append({
\n 'field': key,
\n 'old': old_value,
\n 'new': new_value,
\n 'operation': 'replace' if old_value and new_value else ('add' if new_value else 'remove')
\n })<\/p>\n
return delta<\/p>\n
def is_delta_smaller(self, delta: Dict[str, Any], full_data: Dict[str, Any]) -> bool:
\n """\u68c0\u67e5\u589e\u91cf\u662f\u5426\u6bd4\u5b8c\u6574\u6570\u636e\u5c0f"""
\n delta_size = len(json.dumps(delta))
\n full_size = len(json.dumps(full_data))<\/p>\n
# \u5982\u679c\u589e\u91cf\u5c0f\u4e8e\u5b8c\u6574\u6570\u636e\u768475%，\u5219\u8ba4\u4e3a\u5b83\u66f4\u5c0f
\n return delta_size < full_size * 0.75<\/p>\n
# \u521b\u5efa\u7f16\u7801\u5668\u5b9e\u4f8b
\ndelta_encoder = DeltaEncoder()<\/p>\n
# \u652f\u6301\u589e\u91cf\u7f16\u7801\u7684\u8d44\u6e90\u7aef\u70b9
\n@app.route('\/api\/delta\/<resource_id>', methods=['GET'])
\ndef get_resource_with_delta(resource_id):
\n """\u83b7\u53d6\u8d44\u6e90，\u652f\u6301\u589e\u91cf\u7f16\u7801"""<\/p>\n
# \u83b7\u53d6\u5ba2\u6237\u7aef\u7684ETag（\u53ef\u80fd\u6765\u81eaIf-None-Match）
\n client_etag = request.headers.get('If-None-Match')<\/p>\n
# \u83b7\u53d6\u54cd\u5e94
\n response_info = delta_encoder.get_delta_response(resource_id, client_etag)<\/p>\n
# \u6784\u5efa\u54cd\u5e94
\n if response_info['status'] == 226:
\n # 226 IM Used
\n response = jsonify({
\n 'data': response_info['data'],
\n '_delta': True,
\n '_base_version': request.headers.get('If-None-Match'),
\n '_current_etag': response_info['headers']['ETag']
\n })
\n response.status_code = 226<\/p>\n
# \u8bbe\u7f6e\u5934\u90e8
\n for key, value in response_info['headers'].items():
\n if value is not None:
\n response.headers[key] = value<\/p>\n
# \u6dfb\u52a0\u589e\u91cf\u7f16\u7801\u7279\u5b9a\u7684\u5934\u90e8
\n response.headers['Vary'] = 'If-None-Match'
\n response.headers['Cache-Control'] = 'private, must-revalidate'<\/p>\n
return response<\/p>\n
elif response_info['status'] == 304:
\n # 304 Not Modified
\n response = Response(status=304)
\n response.headers['ETag'] = response_info['headers']['ETag']
\n return response<\/p>\n
else:
\n # 200 OK – \u5b8c\u6574\u8d44\u6e90
\n response = jsonify(response_info['data'])
\n response.headers['ETag'] = response_info['headers']['ETag']
\n response.headers['Cache-Control'] = 'private, must-revalidate'
\n return response<\/p>\n
# \u66f4\u65b0\u8d44\u6e90\u7aef\u70b9
\n@app.route('\/api\/delta\/<resource_id>', methods=['PATCH'])
\ndef update_resource(resource_id):
\n """\u66f4\u65b0\u8d44\u6e90，\u521b\u5efa\u65b0\u7248\u672c"""<\/p>\n
updates = request.json
\n if not updates:
\n return jsonify({'error': 'No updates provided'}), 400<\/p>\n
# \u66f4\u65b0\u8d44\u6e90
\n new_version = delta_encoder.update_resource(resource_id, updates)<\/p>\n
# \u8fd4\u56de\u65b0\u7248\u672c
\n response = jsonify(new_version)
\n response.headers['ETag'] = delta_encoder.generate_etag(new_version)
\n response.headers['Cache-Control'] = 'private, no-cache'<\/p>\n
return response<\/p>\n
# \u83b7\u53d6\u8d44\u6e90\u7248\u672c\u5386\u53f2
\n@app.route('\/api\/delta\/<resource_id>\/history', methods=['GET'])
\ndef get_resource_history(resource_id):
\n """\u83b7\u53d6\u8d44\u6e90\u7684\u7248\u672c\u5386\u53f2"""<\/p>\n
if resource_id not in delta_encoder.resource_versions:
\n return jsonify({'error': 'Resource not found'}), 404<\/p>\n
resource = delta_encoder.resource_versions[resource_id]
\n history = []<\/p>\n
for i, version in enumerate(resource['versions']):
\n history.append({
\n 'version': version['data'].get('version'),
\n 'etag': version['etag'],
\n 'timestamp': version['timestamp'],
\n 'is_current': i == resource['current_index']
\n })<\/p>\n
return jsonify({
\n 'resource_id': resource_id,
\n 'current_version': resource['current_index'] + 1,
\n 'history': history
\n })<\/p>\n
if __name__ == '__main__':
\n app.run(debug=True, port=5005)<\/p>\n
javascript<\/p>\n
\/\/ \u5ba2\u6237\u7aef\u5904\u7406226\u54cd\u5e94\u7684\u793a\u4f8b
\nclass DeltaEncodingClient {
\n \/**
\n * \u5904\u7406\u589e\u91cf\u7f16\u7801（226 IM Used）\u7684\u5ba2\u6237\u7aef
\n *\/<\/p>\n
constructor(resourceUrl) {
\n this.resourceUrl = resourceUrl;
\n this.currentData = null;
\n this.currentEtag = null;
\n this.useDeltaEncoding = true;
\n }<\/p>\n
async fetchResource(forceFull = false) {
\n try {
\n const headers = {};<\/p>\n
\/\/ \u5982\u679c\u5df2\u6709ETag，\u5e76\u4e14\u4e0d\u5f3a\u5236\u83b7\u53d6\u5b8c\u6574\u8d44\u6e90，\u5219\u53d1\u9001If-None-Match
\n if (this.currentEtag && !forceFull && this.useDeltaEncoding) {
\n headers['If-None-Match'] = this.currentEtag;
\n }<\/p>\n
const response = await fetch(this.resourceUrl, { headers });<\/p>\n
if (response.status === 226) {
\n \/\/ \u589e\u91cf\u54cd\u5e94
\n return await this.handle226Response(response);
\n } else if (response.status === 304) {
\n \/\/ \u672a\u4fee\u6539
\n console.log('Resource not modified');
\n return this.currentData;
\n } else if (response.ok) {
\n \/\/ \u5b8c\u6574\u54cd\u5e94
\n return await this.handle200Response(response);
\n } else {
\n throw new Error(`HTTP ${response.status}`);
\n }
\n } catch (error) {
\n console.error('Failed to fetch resource:', error);
\n throw error;
\n }
\n }<\/p>\n
async handle226Response(response) {
\n console.log('Received 226 IM Used (delta encoded) response');<\/p>\n
\/\/ \u83b7\u53d6\u589e\u91cf\u6570\u636e
\n const deltaData = await response.json();
\n const delta = deltaData.data;
\n const newEtag = response.headers.get('ETag');
\n const imHeader = response.headers.get('IM');<\/p>\n
\/\/ \u9a8c\u8bc1\u8fd9\u662f\u5426\u771f\u7684\u662f\u589e\u91cf
\n if (!delta || !delta._delta) {
\n console.warn('Expected delta response but got full data');
\n this.currentData = deltaData;
\n this.currentEtag = newEtag;
\n return this.currentData;
\n }<\/p>\n
\/\/ \u5e94\u7528\u589e\u91cf
\n if (delta.operation === 'patch' && Array.isArray(delta.changes)) {
\n this.applyPatch(delta);
\n } else {
\n console.warn('Unknown delta format:', delta);
\n \/\/ \u56de\u9000\u5230\u5b8c\u6574\u8bf7\u6c42
\n return await this.fetchResource(true);
\n }<\/p>\n
\/\/ \u66f4\u65b0ETag
\n this.currentEtag = newEtag;<\/p>\n
\/\/ \u8bb0\u5f55\u7edf\u8ba1\u4fe1\u606f
\n const deltaSize = JSON.stringify(delta).length;
\n console.log(`Applied delta: ${delta.changes.length} changes, delta size: ${deltaSize} bytes`);<\/p>\n
\/\/ \u89e6\u53d1\u66f4\u65b0\u4e8b\u4ef6
\n this.triggerUpdateEvent('delta-applied', {
\n changes: delta.changes.length,
\n deltaSize,
\n newEtag
\n });<\/p>\n
return this.currentData;
\n }<\/p>\n
applyPatch(delta) {
\n if (!this.currentData) {
\n console.error('Cannot apply patch without base data');
\n return;
\n }<\/p>\n
\/\/ \u5e94\u7528\u6bcf\u4e2a\u53d8\u66f4
\n delta.changes.forEach(change => {
\n switch (change.operation) {
\n case 'replace':
\n this.currentData[change.field] = change.new;
\n break;
\n case 'add':
\n this.currentData[change.field] = change.new;
\n break;
\n case 'remove':
\n delete this.currentData[change.field];
\n break;
\n default:
\n console.warn(`Unknown operation: ${change.operation}`);
\n }
\n });<\/p>\n
\/\/ \u66f4\u65b0\u7248\u672c\u4fe1\u606f
\n if (delta.to_version !== undefined) {
\n this.currentData.version = delta.to_version;
\n }<\/p>\n
this.currentData.updated_at = new Date().toISOString();
\n }<\/p>\n
async handle200Response(response) {
\n console.log('Received 200 OK (full resource) response');<\/p>\n
this.currentData = await response.json();
\n this.currentEtag = response.headers.get('ETag');<\/p>\n
\/\/ \u89e6\u53d1\u66f4\u65b0\u4e8b\u4ef6
\n this.triggerUpdateEvent('full-update', {
\n dataSize: JSON.stringify(this.currentData).length,
\n etag: this.currentEtag
\n });<\/p>\n
return this.currentData;
\n }<\/p>\n
triggerUpdateEvent(type, details) {
\n const event = new CustomEvent('resource-updated', {
\n detail: {
\n type: type,
\n data: this.currentData,
\n etag: this.currentEtag,
\n timestamp: new Date().toISOString(),
\n …details
\n }
\n });<\/p>\n
\/\/ \u5728document\u4e0a\u89e6\u53d1\u4e8b\u4ef6，\u4ee5\u4fbf\u5176\u4ed6\u7ec4\u4ef6\u53ef\u4ee5\u76d1\u542c
\n document.dispatchEvent(event);
\n }<\/p>\n
async updateResource(updates) {
\n try {
\n const response = await fetch(this.resourceUrl, {
\n method: 'PATCH',
\n headers: {
\n 'Content-Type': 'application\/json'
\n },
\n body: JSON.stringify(updates)
\n });<\/p>\n
if (response.ok) {
\n const newData = await response.json();
\n const newEtag = response.headers.get('ETag');<\/p>\n
this.currentData = newData;
\n this.currentEtag = newEtag;<\/p>\n
\/\/ \u89e6\u53d1\u66f4\u65b0\u4e8b\u4ef6
\n this.triggerUpdateEvent('local-update', {
\n updates,
\n newEtag
\n });<\/p>\n
return newData;
\n } else {
\n throw new Error(`Update failed: HTTP ${response.status}`);
\n }
\n } catch (error) {
\n console.error('Failed to update resource:', error);
\n throw error;
\n }
\n }<\/p>\n
\/\/ \u624b\u52a8\u8bbe\u7f6e\u6570\u636e（\u4f8b\u5982\u4ece\u7f13\u5b58\u52a0\u8f7d）
\n setData(data, etag) {
\n this.currentData = data;
\n this.currentEtag = etag;
\n }<\/p>\n
\/\/ \u542f\u7528\/\u7981\u7528\u589e\u91cf\u7f16\u7801
\n setDeltaEncoding(enabled) {
\n this.useDeltaEncoding = enabled;
\n console.log(`Delta encoding ${enabled ? 'enabled' : 'disabled'}`);
\n }<\/p>\n
\/\/ \u83b7\u53d6\u5f53\u524d\u72b6\u6001
\n getStatus() {
\n return {
\n hasData: !!this.currentData,
\n etag: this.currentEtag,
\n usingDelta: this.useDeltaEncoding,
\n dataSize: this.currentData ? JSON.stringify(this.currentData).length : 0
\n };
\n }
\n}<\/p>\n
\/\/ \u4f7f\u7528\u793a\u4f8b
\ndocument.addEventListener('DOMContentLoaded', () => {
\n const client = new DeltaEncodingClient('\/api\/delta\/document-123');<\/p>\n
\/\/ \u76d1\u542c\u8d44\u6e90\u66f4\u65b0\u4e8b\u4ef6
\n document.addEventListener('resource-updated', (event) => {
\n console.log('Resource updated:', event.detail.type);<\/p>\n
\/\/ \u66f4\u65b0UI
\n updateResourceDisplay(event.detail.data);<\/p>\n
\/\/ \u663e\u793a\u901a\u77e5
\n showUpdateNotification(event.detail);
\n });<\/p>\n
\/\/ \u521d\u59cb\u52a0\u8f7d
\n client.fetchResource().then(data => {
\n console.log('Initial load complete:', data);
\n updateResourceDisplay(data);
\n }).catch(error => {
\n console.error('Initial load failed:', error);
\n });<\/p>\n
\/\/ \u5b9a\u671f\u5237\u65b0（\u4f8b\u5982\u6bcf30\u79d2）
\n setInterval(() => {
\n client.fetchResource().catch(error => {
\n console.error('Background refresh failed:', error);
\n });
\n }, 30000);<\/p>\n
\/\/ \u66f4\u65b0\u6309\u94ae
\n document.getElementById('update-resource').addEventListener('click', async () => {
\n const newTitle = prompt('Enter new title:');
\n if (newTitle) {
\n try {
\n await client.updateResource({ title: newTitle });
\n } catch (error) {
\n alert('Update failed: ' + error.message);
\n }
\n }
\n });<\/p>\n
\/\/ \u5207\u6362\u589e\u91cf\u7f16\u7801
\n document.getElementById('toggle-delta').addEventListener('click', () => {
\n const enabled = document.getElementById('toggle-delta').checked;
\n client.setDeltaEncoding(enabled);
\n });
\n});<\/p>\n
function updateResourceDisplay(data) {
\n const container = document.getElementById('resource-container');
\n if (!container) return;<\/p>\n
container.innerHTML = `
\n <h2>${data.title || 'Untitled'}<\/h2>
\n <p><strong>ID:<\/strong> ${data.id}<\/p>
\n <p><strong>Version:<\/strong> ${data.version || 1}<\/p>
\n <p><strong>Content:<\/strong> ${data.content || 'No content'}<\/p>
\n <p><strong>Updated:<\/strong> ${new Date(data.updated_at).toLocaleString()}<\/p>
\n `;
\n}<\/p>\n
function showUpdateNotification(detail) {
\n const notification = document.createElement('div');
\n notification.className = 'notification';<\/p>\n
let message = '';
\n switch (detail.type) {
\n case 'delta-applied':
\n message = `Updated with ${detail.changes} changes (delta: ${detail.deltaSize} bytes)`;
\n notification.classList.add('info');
\n break;
\n case 'full-update':
\n message = `Full update received (${detail.dataSize} bytes)`;
\n notification.classList.add('success');
\n break;
\n case 'local-update':
\n message = 'Local update successful';
\n notification.classList.add('success');
\n break;
\n default:
\n message = 'Resource updated';
\n }<\/p>\n
notification.textContent = message;<\/p>\n
\/\/ \u6dfb\u52a0\u5230\u9875\u9762
\n const container = document.getElementById('notification-container') || createNotificationContainer();
\n container.appendChild(notification);<\/p>\n
\/\/ 3\u79d2\u540e\u81ea\u52a8\u79fb\u9664
\n setTimeout(() => {
\n notification.style.opacity = '0';
\n notification.style.transition = 'opacity 0.5s';<\/p>\n
setTimeout(() => {
\n notification.remove();
\n }, 500);
\n }, 3000);
\n}<\/p>\n
function createNotificationContainer() {
\n const container = document.createElement('div');
\n container.id = 'notification-container';
\n container.style.cssText = `
\n position: fixed;
\n top: 20px;
\n right: 20px;
\n z-index: 1000;
\n `;<\/p>\n
document.body.appendChild(container);
\n return container;
\n}<\/p>\n
| 200 OK<\/td>\n | \u6210\u529f<\/td>\n | \u6807\u51c6\u6210\u529f\u54cd\u5e94<\/td>\n | \u53ef\u9009<\/td>\n | \u53ef\u7f13\u5b58<\/td>\n | \u901a\u7528\u6210\u529f\u54cd\u5e94<\/td>\n<\/tr>\n |
| 201 Created<\/td>\n | \u5df2\u521b\u5efa<\/td>\n | \u8d44\u6e90\u521b\u5efa\u6210\u529f<\/td>\n | \u63a8\u8350<\/td>\n | \u901a\u5e38\u4e0d\u7f13\u5b58<\/td>\n | RESTful API\u521b\u5efa\u64cd\u4f5c<\/td>\n<\/tr>\n |
| 202 Accepted<\/td>\n | \u5df2\u63a5\u53d7<\/td>\n | \u5f02\u6b65\u8bf7\u6c42\u63a5\u53d7<\/td>\n | \u53ef\u9009<\/td>\n | \u4e0d\u7f13\u5b58<\/td>\n | \u957f\u65f6\u95f4\u8fd0\u884c\u4efb\u52a1<\/td>\n<\/tr>\n |
| 203 Non-Authoritative<\/td>\n | \u975e\u6743\u5a01\u4fe1\u606f<\/td>\n | \u4ee3\u7406\u4fee\u6539\u7684\u54cd\u5e94<\/td>\n | \u53ef\u9009<\/td>\n | \u53ef\u7f13\u5b58<\/td>\n | \u4ee3\u7406\/\u7f13\u5b58\u670d\u52a1\u5668<\/td>\n<\/tr>\n |
| 204 No Content<\/td>\n | \u65e0\u5185\u5bb9<\/td>\n | \u6210\u529f\u4f46\u65e0\u8fd4\u56de<\/td>\n | \u7981\u6b62<\/td>\n | \u901a\u5e38\u4e0d\u7f13\u5b58<\/td>\n | \u5220\u9664\u3001\u66f4\u65b0\u64cd\u4f5c<\/td>\n<\/tr>\n |
| 205 Reset Content<\/td>\n | \u91cd\u7f6e\u5185\u5bb9<\/td>\n | \u91cd\u7f6e\u5ba2\u6237\u7aef\u89c6\u56fe<\/td>\n | \u7981\u6b62<\/td>\n | \u4e0d\u7f13\u5b58<\/td>\n | \u8868\u5355\u63d0\u4ea4\u540e\u91cd\u7f6e<\/td>\n<\/tr>\n |
| 206 Partial Content<\/td>\n | \u90e8\u5206\u5185\u5bb9<\/td>\n | \u8303\u56f4\u8bf7\u6c42\u6210\u529f<\/td>\n | \u5fc5\u987b<\/td>\n | \u53ef\u7f13\u5b58<\/td>\n | \u5927\u6587\u4ef6\u4e0b\u8f7d\u3001\u6d41\u5a92\u4f53<\/td>\n<\/tr>\n |
| 207 Multi-Status<\/td>\n | \u591a\u72b6\u6001<\/td>\n | \u6279\u91cf\u64cd\u4f5c\u7ed3\u679c<\/td>\n | XML\u5fc5\u987b<\/td>\n | \u4e0d\u7f13\u5b58<\/td>\n | WebDAV\u3001\u6279\u91cfAPI<\/td>\n<\/tr>\n |
| 208 Already Reported<\/td>\n | \u5df2\u62a5\u544a<\/td>\n | \u907f\u514d\u91cd\u590d\u679a\u4e3e<\/td>\n | XML\u53ef\u9009<\/td>\n | \u4e0d\u7f13\u5b58<\/td>\n | WebDAV\u7ed1\u5b9a\u96c6\u5408<\/td>\n<\/tr>\n |
| 226 IM Used<\/td>\n | IM\u5df2\u4f7f\u7528<\/td>\n | \u589e\u91cf\u7f16\u7801\u54cd\u5e94<\/td>\n | \u5fc5\u987b<\/td>\n | \u53ef\u7f13\u5b58<\/td>\n | \u589e\u91cf\u66f4\u65b0\u3001\u5dee\u5206\u7f16\u7801<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n\u9009\u62e9\u6307\u5357<\/h4>\npython<\/p>\n # 2xx\u72b6\u6001\u7801\u9009\u62e9\u51b3\u7b56\u6811 @staticmethod Args: Returns: method = scenario.get('method', 'GET') # \u7279\u6b8a\u60c5\u51b5：\u8303\u56f4\u8bf7\u6c42 # \u7279\u6b8a\u60c5\u51b5：\u6279\u91cf\u64cd\u4f5c（WebDAV\u98ce\u683c） # \u7279\u6b8a\u60c5\u51b5：\u4ee3\u7406\u8f6c\u6362\u7684\u54cd\u5e94 # \u7279\u6b8a\u60c5\u51b5：\u5ba2\u6237\u7aef\u9700\u8981\u91cd\u7f6e # \u6839\u636e\u65b9\u6cd5\u548c\u64cd\u4f5c\u9009\u62e9 elif action == 'delete': elif action == 'update': elif action == 'read': else: @staticmethod practices = { return practices.get(status_code, {})<\/p>\n 9.7 \u5b9e\u9645\u5e94\u7528\u6848\u4f8b<\/h3>\n |