import repository from arizona
[raven.git] / 2.0 / python / storks3.py
1 #! /usr/bin/env python
2 """
3 Stork Project (http://www.cs.arizona.edu/stork/)
4 Module: arizonacrypt
5 Description:
6 """
7
8
9 # This sets up the options for arizonaconfig
10 #           [option, long option,  variable,   action,  data,     default,  metavar,    description]#
11 """arizonaconfig
12    options=[["",     "--awskey",         "awskey",         "store",    "string",    None,    None,  "AWS key for S3"],
13             ["",     "--awssecretkey",   "awssecretkey",   "store",    "string",    None,    None,  "AWS secret key for S3"],
14             ["",     "--awsbucket",      "awsbucket",      "store",    "string",    "stork",    None,  "AWS bucket name"]]
15    includes=[]
16 """
17
18 import sys
19 import re
20 import os.path
21 import tempfile
22 import shutil
23 import arizonareport
24 import arizonaconfig
25 import arizonageneral
26
27 # import the amazon S3 code
28 import s3.S3 as S3
29
30 glo_aws_conn = None
31 glo_aws_generator = None
32 glo_aws_bucket = None
33 glo_initialized = False
34
35 def init():
36    global glo_aws_conn
37    global glo_aws_generator
38    global glo_aws_bucket
39    global glo_initialized
40
41    if glo_initialized:
42        return True
43
44    awskey = arizonaconfig.get_option("awskey")
45    awssecretkey = arizonaconfig.get_option("awssecretkey")
46    bucket = arizonaconfig.get_option("awsbucket")
47
48    if (not awskey) or (not awssecretkey):
49       raise TypeError, "Please configure your awskey and awssecretkey"
50
51    glo_aws_conn = S3.AWSAuthConnection(awskey, awssecretkey)
52    glo_aws_generator = S3.QueryStringAuthGenerator(awskey, awssecretkey)
53
54    if bucket[0] == '*':
55       # if the user puts a '*' as the first character, then lets assume he
56       # wants to specify an absolete bucket name, and not prepend the
57       # awskey
58       glo_aws_bucket = bucket[1:]
59    else:
60       glo_aws_bucket = awskey.lower() + bucket
61
62    # create the bucket in case it does not exist
63    glo_aws_conn.create_bucket(glo_aws_bucket)
64
65    glo_initialized = True
66
67 def dumpbuckets():
68    global glo_aws_conn
69    global glo_aws_bucket
70
71    result = glo_aws_conn.list_all_my_buckets()
72
73    if result.http_response.status != 200:
74        raise TypeError, result.http_response.reason
75
76    for entry in result.entries:
77        print str(entry.name)
78
79 def dumpdir():
80    entries = readdir()
81
82    for entry in entries:
83        print str(entry.key) + " " + str(entry.size)
84
85 def get_highestkey(entries):
86     highestkey = None
87     for entry in entries:
88         if (highestkey == None) or (entry.key > highestkey):
89             highestkey = entry.key
90     return highestkey
91
92 def readdir():
93    global glo_aws_conn
94    global glo_aws_bucket
95
96    entries = []
97
98    # start reading from the top, so set marker=None
99    marker = None
100    more = True
101
102    while more:
103       # if we have a marker from the previous call to list_bucket, then we'll
104       # use that marker as the place to start this readdir
105       query = {}
106       if marker:
107           query['marker'] = marker
108
109       result = glo_aws_conn.list_bucket(glo_aws_bucket, query)
110
111       if result.http_response.status != 200:
112           raise TypeError, result.http_response.reason
113
114       entries.extend(result.entries)
115
116       # is_truncated indicates that there are more entries to read. We'll get
117       # the next_marker by finding the highest key that S3 returned to us.
118       if result.is_truncated:
119          more = True;
120          marker = get_highestkey(entries)
121       else:
122          more = False
123
124    return entries
125
126 def put_file(local_filename, remote_name, metadata={}):
127    global glo_aws_conn
128    global glo_aws_bucket
129
130    # read the local file
131    fileobj = file(local_filename,'r')
132    content = fileobj.read()
133    fileobj.close()
134
135    # make a copy since we will be modifying it
136    metadata = metadata.copy()
137
138    metadata['local-filename'] = local_filename
139
140    # create an S3 object to hold it
141    obj = S3.S3Object(content, metadata)
142
143    # the public-read acl allows us to use torrents
144    headers = { 'Content-Type': 'Application/Octet',
145                'x-amz-acl': 'public-read' }
146
147    result = glo_aws_conn.put(glo_aws_bucket, remote_name, obj, headers)
148
149    if result.http_response.status != 200:
150        arizoanreport.send_error(0, "s3 error " + str(result))
151        raise TypeError, result.http_response.reason
152
153 def get_file(remote_name, local_filename):
154    global glo_aws_conn
155    global glo_aws_bucket
156
157    result = glo_aws_conn.get(glo_aws_bucket, remote_name)
158
159    if result.http_response.status != 200:
160        arizonareport.send_error(0, "s3: " + str(result.http_response.reason))
161        raise TypeError, result.http_response.reason
162
163    # if local_filename == None, then try to get it from the S3 metadata for
164    # this object
165    if not local_filename:
166        local_filename = result.object.metadata.get('local-filename', None)
167        if not local_filename:
168            arizonareport.send_error(0, "s3: unable to determine local filename")
169            raise TypeError, "unable to determine local filename"
170
171    fileobj = file(local_filename, 'w')
172    fileobj.write(result.object.data)
173    fileobj.close()
174
175    return result.object.metadata
176
177 def destroy():
178    global glo_aws_conn
179    global glo_aws_bucket
180
181    entries = readdir()
182
183    for entry in entries:
184        result = glo_aws_conn.delete(glo_aws_bucket, entry.key)
185        arizonareport.send_out(1, "delete: " + entry.key + " result=" + \
186            str(result.http_response.status))
187
188    result = glo_aws_conn.delete_bucket(glo_aws_bucket)
189    arizonareport.send_out(1, "delete bucket result=" + \
190        str(result.http_response.status))
191