Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Commit b48487d

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

File tree

6 files changed

+484
-2
lines changed

6 files changed

+484
-2
lines changed

‎storage/cloud-client/README.rst

Lines 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

Lines 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

Lines 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)