Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Appearance settings

Commit b48487d

Browse filesBrowse files
billyjacobsonkurtisvg
billyjacobson
authored and
kurtisvg
committed
Bucket lock samples (GoogleCloudPlatform#1588)
1 parent 11757b9 commit b48487d
Copy full SHA for b48487d

File tree

Expand file treeCollapse file tree

6 files changed

+484
-2
lines changed
Filter options
Expand file treeCollapse file tree

6 files changed

+484
-2
lines changed

‎storage/cloud-client/README.rst

Copy file name to clipboardExpand all lines: storage/cloud-client/README.rst
+49Lines changed: 49 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -251,6 +251,55 @@ To run this sample:
251251
252252
253253
254+
Bucket Lock
255+
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
256+
257+
.. image:: https://gstatic.com/cloudssh/images/open-btn.png
258+
:target: https://console.cloud.google.com/cloudshell/open?git_repo=https://github.com/GoogleCloudPlatform/python-docs-samples&page=editor&open_in_editor=storage/cloud-client/bucket_lock.py,storage/cloud-client/README.rst
259+
260+
261+
262+
263+
To run this sample:
264+
265+
.. code-block:: bash
266+
267+
$ python bucket_lock.py
268+
269+
usage: bucket_lock.py [-h]
270+
{set-retention-policy,remove-retention-policy,lock-retention-policy,get-retention-policy,set-temporary-hold,release-temporary-hold,set-event-based-hold,release-event-based-hold,enable-default-event-based-hold,disable-default-event-based-hold,get-default-event-based-hold}
271+
...
272+
273+
positional arguments:
274+
{set-retention-policy,remove-retention-policy,lock-retention-policy,get-retention-policy,set-temporary-hold,release-temporary-hold,set-event-based-hold,release-event-based-hold,enable-default-event-based-hold,disable-default-event-based-hold,get-default-event-based-hold}
275+
set-retention-policy
276+
Defines a retention policy on a given bucket
277+
remove-retention-policy
278+
Removes the retention policy on a given bucket
279+
lock-retention-policy
280+
Locks the retention policy on a given bucket
281+
get-retention-policy
282+
Gets the retention policy on a given bucket
283+
set-temporary-hold Sets a temporary hold on a given blob
284+
release-temporary-hold
285+
Releases the temporary hold on a given blob
286+
set-event-based-hold
287+
Sets a event based hold on a given blob
288+
release-event-based-hold
289+
Releases the event based hold on a given blob
290+
enable-default-event-based-hold
291+
Enables the default event based hold on a given bucket
292+
disable-default-event-based-hold
293+
Disables the default event based hold on a given
294+
bucket
295+
get-default-event-based-hold
296+
Gets the default event based hold on a given bucket
297+
298+
optional arguments:
299+
-h, --help show this help message and exit
300+
301+
302+
254303
Notification Polling
255304
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
256305

‎storage/cloud-client/README.rst.in

Copy file name to clipboardExpand all lines: storage/cloud-client/README.rst.in
+3Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,9 @@ samples:
2424
- name: Customer-Supplied Encryption
2525
file: encryption.py
2626
show_help: true
27+
- name: Bucket Lock
28+
file: bucket_lock.py
29+
show_help: true
2730
- name: Notification Polling
2831
file: notification_polling.py
2932
show_help: true

‎storage/cloud-client/bucket_lock.py

Copy file name to clipboard
+287Lines changed: 287 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,287 @@
1+
#!/usr/bin/env python
2+
3+
# Copyright 2018 Google Inc. All Rights Reserved.
4+
#
5+
# Licensed under the Apache License, Version 2.0 (the 'License');
6+
# you may not use this file except in compliance with the License.
7+
# You may obtain a copy of the License at
8+
#
9+
# http://www.apache.org/licenses/LICENSE-2.0
10+
#
11+
# Unless required by applicable law or agreed to in writing, software
12+
# distributed under the License is distributed on an "AS IS" BASIS,
13+
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14+
# See the License for the specific language governing permissions and
15+
# limitations under the License.
16+
17+
import argparse
18+
19+
from google.cloud import storage
20+
21+
22+
def set_retention_policy(bucket_name, retention_period):
23+
"""Defines a retention policy on a given bucket"""
24+
# [START storage_set_retention_policy]
25+
# bucket_name = "my-bucket"
26+
# retention_period = 10
27+
storage_client = storage.Client()
28+
bucket = storage_client.bucket(bucket_name)
29+
30+
bucket.retention_period = retention_period
31+
bucket.patch()
32+
33+
print('Bucket {} retention period set for {} seconds'.format(
34+
bucket.name,
35+
bucket.retention_period))
36+
# [END storage_set_retention_policy]
37+
38+
39+
def remove_retention_policy(bucket_name):
40+
"""Removes the retention policy on a given bucket"""
41+
# [START storage_remove_retention_policy]
42+
# bucket_name = "my-bucket"
43+
storage_client = storage.Client()
44+
bucket = storage_client.bucket(bucket_name)
45+
bucket.reload()
46+
47+
if bucket.retention_policy_locked:
48+
print(
49+
'Unable to remove retention period as retention policy is locked.')
50+
return
51+
52+
bucket.retention_period = None
53+
bucket.patch()
54+
55+
print('Removed bucket {} retention policy'.format(bucket.name))
56+
# [END storage_remove_retention_policy]
57+
58+
59+
def lock_retention_policy(bucket_name):
60+
"""Locks the retention policy on a given bucket"""
61+
# [START storage_lock_retention_policy]
62+
# bucket_name = "my-bucket"
63+
storage_client = storage.Client()
64+
# get_bucket gets the current metageneration value for the bucket,
65+
# required by lock_retention_policy.
66+
bucket = storage_client.get_bucket(bucket_name)
67+
68+
# Warning: Once a retention policy is locked it cannot be unlocked
69+
# and retention period can only be increased.
70+
bucket.lock_retention_policy()
71+
72+
print('Retention policy for {} is now locked'.format(bucket_name))
73+
print('Retention policy effective as of {}'.format(
74+
bucket.retention_policy_effective_time))
75+
# [END storage_lock_retention_policy]
76+
77+
78+
def get_retention_policy(bucket_name):
79+
"""Gets the retention policy on a given bucket"""
80+
# [START storage_get_retention_policy]
81+
# bucket_name = "my-bucket"
82+
storage_client = storage.Client()
83+
bucket = storage_client.bucket(bucket_name)
84+
bucket.reload()
85+
86+
print('Retention Policy for {}'.format(bucket_name))
87+
print('Retention Period: {}'.format(bucket.retention_period))
88+
if bucket.retention_policy_locked:
89+
print('Retention Policy is locked')
90+
91+
if bucket.retention_policy_effective_time:
92+
print('Effective Time: {}'
93+
.format(bucket.retention_policy_effective_time))
94+
# [END storage_get_retention_policy]
95+
96+
97+
def set_temporary_hold(bucket_name, blob_name):
98+
"""Sets a temporary hold on a given blob"""
99+
# [START storage_set_temporary_hold]
100+
# bucket_name = "my-bucket"
101+
# blob_name = "my-blob"
102+
storage_client = storage.Client()
103+
bucket = storage_client.bucket(bucket_name)
104+
blob = bucket.blob(blob_name)
105+
106+
blob.temporary_hold = True
107+
blob.patch()
108+
109+
print("Temporary hold was set for #{blob_name}")
110+
# [END storage_set_temporary_hold]
111+
112+
113+
def release_temporary_hold(bucket_name, blob_name):
114+
"""Releases the temporary hold on a given blob"""
115+
# [START storage_release_temporary_hold]
116+
# bucket_name = "my-bucket"
117+
# blob_name = "my-blob"
118+
storage_client = storage.Client()
119+
bucket = storage_client.bucket(bucket_name)
120+
blob = bucket.blob(blob_name)
121+
122+
blob.temporary_hold = False
123+
blob.patch()
124+
125+
print("Temporary hold was release for #{blob_name}")
126+
# [END storage_release_temporary_hold]
127+
128+
129+
def set_event_based_hold(bucket_name, blob_name):
130+
"""Sets a event based hold on a given blob"""
131+
# [START storage_set_event_based_hold]
132+
# bucket_name = "my-bucket"
133+
# blob_name = "my-blob"
134+
storage_client = storage.Client()
135+
bucket = storage_client.bucket(bucket_name)
136+
blob = bucket.blob(blob_name)
137+
138+
blob.event_based_hold = True
139+
blob.patch()
140+
141+
print('Event based hold was set for {}'.format(blob_name))
142+
# [END storage_set_event_based_hold]
143+
144+
145+
def release_event_based_hold(bucket_name, blob_name):
146+
"""Releases the event based hold on a given blob"""
147+
# [START storage_release_event_based_hold]
148+
# bucket_name = "my-bucket"
149+
# blob_name = "my-blob"
150+
storage_client = storage.Client()
151+
bucket = storage_client.bucket(bucket_name)
152+
blob = bucket.blob(blob_name)
153+
154+
blob.event_based_hold = False
155+
blob.patch()
156+
157+
print('Event based hold was released for {}'.format(blob_name))
158+
# [END storage_release_event_based_hold]
159+
160+
161+
def enable_default_event_based_hold(bucket_name):
162+
"""Enables the default event based hold on a given bucket"""
163+
# [START storage_enable_default_event_based_hold]
164+
# bucket_name = "my-bucket"
165+
storage_client = storage.Client()
166+
bucket = storage_client.bucket(bucket_name)
167+
168+
bucket.default_event_based_hold = True
169+
bucket.patch()
170+
171+
print('Default event based hold was enabled for {}'.format(bucket_name))
172+
# [END storage_enable_default_event_based_hold]
173+
174+
175+
def disable_default_event_based_hold(bucket_name):
176+
"""Disables the default event based hold on a given bucket"""
177+
# [START storage_disable_default_event_based_hold]
178+
# bucket_name = "my-bucket"
179+
storage_client = storage.Client()
180+
bucket = storage_client.bucket(bucket_name)
181+
182+
bucket.default_event_based_hold = False
183+
bucket.patch()
184+
185+
print("Default event based hold was disabled for {}".format(bucket_name))
186+
# [END storage_disable_default_event_based_hold]
187+
188+
189+
def get_default_event_based_hold(bucket_name):
190+
"""Gets the default event based hold on a given bucket"""
191+
# [START storage_get_default_event_based_hold]
192+
# bucket_name = "my-bucket"
193+
storage_client = storage.Client()
194+
bucket = storage_client.bucket(bucket_name)
195+
bucket.reload()
196+
197+
if bucket.default_event_based_hold:
198+
print('Default event-based hold is enabled for {}'.format(bucket_name))
199+
else:
200+
print('Default event-based hold is not enabled for {}'
201+
.format(bucket_name))
202+
# [END storage_get_default_event_based_hold]
203+
204+
205+
if __name__ == '__main__':
206+
207+
parser = argparse.ArgumentParser(
208+
description=__doc__,
209+
formatter_class=argparse.RawDescriptionHelpFormatter)
210+
subparsers = parser.add_subparsers(dest='command')
211+
212+
set_retention_policy_parser = subparsers.add_parser(
213+
'set-retention-policy', help=set_retention_policy.__doc__)
214+
set_retention_policy_parser.add_argument('bucket_name')
215+
set_retention_policy_parser.add_argument('retention_period')
216+
217+
remove_retention_policy_parser = subparsers.add_parser(
218+
'remove-retention-policy', help=remove_retention_policy.__doc__)
219+
remove_retention_policy_parser.add_argument('bucket_name')
220+
221+
lock_retention_policy_parser = subparsers.add_parser(
222+
'lock-retention-policy', help=lock_retention_policy.__doc__)
223+
lock_retention_policy_parser.add_argument('bucket_name')
224+
225+
get_retention_policy_parser = subparsers.add_parser(
226+
'get-retention-policy', help=get_retention_policy.__doc__)
227+
get_retention_policy_parser.add_argument('bucket_name')
228+
229+
set_temporary_hold_parser = subparsers.add_parser(
230+
'set-temporary-hold', help=set_temporary_hold.__doc__)
231+
set_temporary_hold_parser.add_argument('bucket_name')
232+
set_temporary_hold_parser.add_argument('blob_name')
233+
234+
release_temporary_hold_parser = subparsers.add_parser(
235+
'release-temporary-hold', help=release_temporary_hold.__doc__)
236+
release_temporary_hold_parser.add_argument('bucket_name')
237+
release_temporary_hold_parser.add_argument('blob_name')
238+
239+
set_event_based_hold_parser = subparsers.add_parser(
240+
'set-event-based-hold', help=set_event_based_hold.__doc__)
241+
set_event_based_hold_parser.add_argument('bucket_name')
242+
set_event_based_hold_parser.add_argument('blob_name')
243+
244+
release_event_based_hold_parser = subparsers.add_parser(
245+
'release-event-based-hold', help=release_event_based_hold.__doc__)
246+
release_event_based_hold_parser.add_argument('bucket_name')
247+
release_event_based_hold_parser.add_argument('blob_name')
248+
249+
enable_default_event_based_hold_parser = subparsers.add_parser(
250+
'enable-default-event-based-hold',
251+
help=enable_default_event_based_hold.__doc__)
252+
enable_default_event_based_hold_parser.add_argument('bucket_name')
253+
254+
disable_default_event_based_hold_parser = subparsers.add_parser(
255+
'disable-default-event-based-hold',
256+
help=disable_default_event_based_hold.__doc__)
257+
disable_default_event_based_hold_parser.add_argument('bucket_name')
258+
259+
get_default_event_based_hold_parser = subparsers.add_parser(
260+
'get-default-event-based-hold',
261+
help=get_default_event_based_hold.__doc__)
262+
get_default_event_based_hold_parser.add_argument('bucket_name')
263+
264+
args = parser.parse_args()
265+
266+
if args.command == 'set-retention-policy':
267+
set_retention_policy(args.bucket_name, args.retention_period)
268+
elif args.command == 'remove-retention-policy':
269+
remove_retention_policy(args.bucket_name)
270+
elif args.command == 'lock-retention-policy':
271+
lock_retention_policy(args.bucket_name)
272+
elif args.command == 'get-retention-policy':
273+
get_retention_policy(args.bucket_name)
274+
elif args.command == 'set-temporary-hold':
275+
set_temporary_hold(args.bucket_name, args.blob_name)
276+
elif args.command == 'release-temporary-hold':
277+
release_temporary_hold(args.bucket_name, args.blob_name)
278+
elif args.command == 'set-event-based-hold':
279+
set_event_based_hold(args.bucket_name, args.blob_name)
280+
elif args.command == 'release-event-based-hold':
281+
release_event_based_hold(args.bucket_name, args.blob_name)
282+
elif args.command == 'enable-default-event-based-hold':
283+
enable_default_event_based_hold(args.bucket_name)
284+
elif args.command == 'disable-default-event-based-hold':
285+
disable_default_event_based_hold(args.bucket_name)
286+
elif args.command == 'get-default-event-based-hold':
287+
get_default_event_based_hold(args.bucket_name)

0 commit comments

Comments
0 (0)
Morty Proxy This is a proxified and sanitized view of the page, visit original site.