1
=== added file 'scripts/__init__.py'
2
=== added file 'scripts/publish_to_snapshots.py'
3
--- scripts/publish_to_snapshots.py	1970-01-01 00:00:00 +0000
4
+++ scripts/publish_to_snapshots.py	2012-03-14 08:03:18 +0000
5
@@ -0,0 +1,142 @@
6
1
#!/usr/bin/env python
7
2
# This script moves the artifacts from tmp location to a
8
3
# to a permanent location on s.l.o
9
4
10
5
import os
11
6
import sys
12
7
import shutil
13
8
import argparse
14
9
15
10
parser = argparse.ArgumentParser()
16
11
parser.add_argument("-t", "--job-type", dest="job_type",
17
12
                    help="Specify the job type (Ex: android/kernel-hwpack)")
18
13
parser.add_argument("-r", "--ktree", dest="kernel_tree",
19
14
                    help="Specify the kernel tree built by the job")
20
15
parser.add_argument("-j", "--job-name", dest="job_name",
21
16
                    help="Specify the job name which resulted the archive to be stored.\
22
17
                    Ex: ${JOB_NAME} should be specified for andriod and for \
23
18
                    kernel-hwpack ${KERNEL_JOB_NAME}")
24
19
parser.add_argument("-n", "--build-num", dest="build_num", type=int,
25
20
                    help="Specify the job build number for android builds only")
26
21
27
22
uploads_path = '/srv3/snapshots.linaro.org/uploads/'
28
23
target_path = '/srv3/snapshots.linaro.org/www/'
29
24
PASS = 0 
30
25
FAIL = 1
31
26
acceptable_job_types = [
32
27
    'android',
33
28
    'kernel-hwpack',
34
29
    ]
35
30
36
31
class SnapshotsPublisher(object):
37
32
 
38
33
    def validate_args(self, args):
39
34
        # Validate that all the required information 
40
35
        # is passed on the command line
41
36
        if (args.job_type == None or  args.job_name == None): 
42
37
            parser.error("\nYou must specify job-type and job-name")
43
38
            return FAIL
44
39
45
40
        if (args.job_type == "android" and args.build_num == None):
46
41
            parser.error("You must specify build number")
47
42
            return FAIL
48
43
49
44
        if (args.job_type == "kernel-hwpack" and args.kernel_tree == None):
50
45
            parser.error("You must specify kernel tree name built by the job")
51
46
            return FAIL
52
47
53
48
        if (args.job_type not in acceptable_job_types):
54
49
            parser.error("Invalid job type")
55
50
            return FAIL
56
51
57
52
    def jobname_to_target_subdir(self, args, jobname):
58
53
        ret_val = None
59
54
        if args.job_type == "android":
60
55
            ret_val = jobname.split("_")    
61
56
        return ret_val 
62
57
63
58
    def validate_paths(self, args, uploads_path, target_path):
64
59
        build_dir_path = target_dir_path = None
65
60
        if args.job_type == "android":
66
61
           build_path = '/'.join([args.job_type, args.job_name,
67
62
                                  str(args.build_num)])
68
63
           build_dir_path = os.path.join(uploads_path, build_path) 
69
64
           ret_val = self.jobname_to_target_subdir(args, args.job_name)
70
65
           if ret_val != None:
71
66
               user_name = ret_val[0]
72
67
               job_name = '_'.join(ret_val[1:])
73
68
               target_dir = '/'.join([args.job_type, user_name, job_name,
74
69
                                      str(args.build_num)])
75
70
               target_dir_path = os.path.join(target_path, target_dir)
76
71
           else:
77
72
               return None, None
78
73
        else:
79
74
           build_path = '/'.join([args.job_type, args.kernel_tree, args.job_name])
80
75
           build_dir_path = os.path.join(uploads_path, build_path)
81
76
           target_dir_path = os.path.join(target_path, build_path)
82
77
83
78
        if not (os.path.isdir(uploads_path) or os.path.isdir(build_dir_path)):
84
79
            build_paths = "'%s' or '%s'" % (uploads_path, build_dir_path)
85
80
            print "Missing build paths: ", build_paths
86
81
            return None, None
87
82
       
88
83
        if not os.path.isdir(target_path):
89
84
            print "Missing target path", target_path
90
85
            return None, None
91
86
92
87
        return build_dir_path, target_dir_path
93
88
94
89
95
90
    def move_artifacts(self, args, build_dir_path, target_dir_path):
96
91
        try:
97
92
            # Make a note of the contents of src dir so that 
98
93
            # it can be used to validate the move to destination
99
94
            uploads_dir_list = os.listdir(build_dir_path)
100
95
101
96
            if not os.path.isdir(target_dir_path):
102
97
                os.makedirs(target_dir_path)
103
98
                if not os.path.isdir(target_dir_path):
104
99
                    raise OSError
105
100
106
101
            for fname in uploads_dir_list:
107
102
                fname = os.path.join(build_dir_path, fname)
108
103
                shutil.copy2(fname, target_dir_path)
109
104
110
105
            target_dir_list = os.listdir(target_dir_path)
111
106
            for fname in uploads_dir_list:
112
107
                if not fname in target_dir_list:
113
108
                    print "Destination missing file", fname
114
109
                    return FAIL
115
110
116
111
            shutil.rmtree(build_dir_path)
117
112
            print "Moved the files from '",build_dir_path, "' to '",\
118
113
                  target_dir_path, "'"
119
114
            return PASS
120
115
121
116
        except OSError, details:
122
117
            print "Failed to create the target path", target_dir_path, ":" , details 
123
118
            return FAIL
124
119
        except shutil.Error:
125
120
            print "Failed to move files destination path", target_dir_path
126
121
            print "Target already exists, move failed"
127
122
            return FAIL
128
123
129
124
def main():
130
125
    publisher = SnapshotsPublisher()
131
126
    args = parser.parse_args()
132
127
    publisher.validate_args(args)
133
128
    build_dir_path, target_dir_path = publisher.validate_paths(args, uploads_path, 
134
129
                                                               target_path)
135
130
    if build_dir_path == None or target_dir_path == None:
136
131
        print "Problem with build/target path, move failed"
137
132
        return FAIL
138
133
139
134
    ret  = publisher.move_artifacts(args, build_dir_path, target_dir_path)
140
135
    if ret != PASS:
141
136
        print "Move Failed"
142
137
        return FAIL
143
138
    else:
144
139
        print "Move succeeded"
145
140
        return PASS
146
141
if __name__ == '__main__':
147
142
    sys.exit(main())
148
0
143
149
=== modified file 'testing/__init__.py'
150
--- testing/__init__.py	2012-01-12 14:07:05 +0000
151
+++ testing/__init__.py	2012-03-14 08:03:18 +0000
152
@@ -1,9 +1,13 @@
153
1
import os
1
import os
154
2
import unittest
2
import unittest
155
3
3
156
4
from testing.test_click_through_license import *
157
5
from testing.test_publish_to_snapshots import *
158
6
159
4
def test_suite():
7
def test_suite():
160
5
    module_names = [
8
    module_names = [
162
6
        'testing.test_click_through_license',
9
        'testing.test_click_through_license.TestLicense',
163
10
        'testing.test_publish_to_snapshots.TestSnapshotsPublisher',
164
7
        ]
11
        ]
165
8
    loader = unittest.TestLoader()
12
    loader = unittest.TestLoader()
166
9
    suite = loader.loadTestsFromNames(module_names)
13
    suite = loader.loadTestsFromNames(module_names)
167
10
14
168
=== added file 'testing/test_publish_to_snapshots.py'
169
--- testing/test_publish_to_snapshots.py	1970-01-01 00:00:00 +0000
170
+++ testing/test_publish_to_snapshots.py	2012-03-14 08:03:18 +0000
171
@@ -0,0 +1,183 @@
172
1
#!/usr/bin/env python
173
2
174
3
import os
175
4
import sys
176
5
import shutil
177
6
import tempfile
178
7
import argparse
179
8
from StringIO import StringIO
180
9
from testtools import TestCase
181
10
from scripts.publish_to_snapshots import SnapshotsPublisher
182
11
183
12
class TestSnapshotsPublisher(TestCase):
184
13
    '''Tests for publishing files to the snapshots.l.o www are.'''
185
14
186
15
    uploads_path = "./uploads/"
187
16
    target_path = "./www/"
188
17
189
18
    def setUp(self):
190
19
        self.parser =  argparse.ArgumentParser()
191
20
        self.parser.add_argument("-t", "--job-type", dest="job_type")
192
21
        self.parser.add_argument("-r", "--ktree", dest="kernel_tree")
193
22
        self.parser.add_argument("-j", "--job-name", dest="job_name")
194
23
        self.parser.add_argument("-n", "--build-num", dest="build_num", type=int)
195
24
        if not os.path.isdir(self.uploads_path):
196
25
            os.mkdir(self.uploads_path)
197
26
        
198
27
        if not os.path.isdir(self.target_path):
199
28
            os.mkdir(self.target_path)
200
29
        super(TestSnapshotsPublisher, self).setUp()
201
30
202
31
    def tearDown(self):
203
32
        if os.path.isdir(self.uploads_path):
204
33
            shutil.rmtree(self.uploads_path)
205
34
206
35
        if os.path.isdir(self.target_path):
207
36
            shutil.rmtree(self.target_path)
208
37
        super(TestSnapshotsPublisher, self).tearDown()
209
38
210
39
    def test_validate_args_valid_job_values(self):
211
40
        self.publisher = SnapshotsPublisher()
212
41
        param = self.parser.parse_args(['-t', 'android', '-j', 'dummy_job_name', '-n', '1'])
213
42
        self.publisher.validate_args(param)
214
43
        param = self.parser.parse_args(['-t', 'kernel-hwpack', '-r', 'dummy_tree', 
215
44
                                        '-j', 'dummy_job_name'])
216
45
        self.publisher.validate_args(param)
217
46
218
47
    def test_validate_args_invalid_job_type(self):
219
48
        orig_stderr = sys.stderr
220
49
        stderr = sys.stderr = StringIO()
221
50
        self.publisher = SnapshotsPublisher()
222
51
        param = self.parser.parse_args(['-t', 'invalid_job_type',  '-j', 'dummy_job_name', 
223
52
                                        '-n', '1'])
224
53
        try:
225
54
            self.publisher.validate_args(param)
226
55
        except SystemExit, err:
227
56
            self.assertEqual(err.code, 2, "Expected result")
228
57
        finally:
229
58
            sys.stderr = orig_stderr
230
59
        stderr.seek(0)
231
60
        self.assertIn("Invalid job type", stderr.read())
232
61
233
62
234
63
    def test_validate_args_run_invalid_argument(self):
235
64
        orig_stderr = sys.stderr
236
65
        stderr = sys.stderr = StringIO()
237
66
        self.publisher = SnapshotsPublisher()
238
67
        try:
239
68
            param = self.parser.parse_args(['-a'])
240
69
            self.publisher.validate_args(param)
241
70
        except SystemExit, err:
242
71
            self.assertEqual(err.code, 2, "Invalid argument passed")
243
72
        finally:
244
73
            sys.stderr = orig_stderr
245
74
        stderr.seek(0)
246
75
        self.assertIn("unrecognized arguments: -a\n", stderr.read())
247
76
248
77
    def test_validate_args_run_invalid_value(self):
249
78
        orig_stderr = sys.stderr
250
79
        stderr = sys.stderr = StringIO()
251
80
        self.publisher = SnapshotsPublisher()
252
81
        try:
253
82
            param = self.parser.parse_args(['-n', "N"])
254
83
            self.publisher.validate_args(param)
255
84
        except SystemExit, err:
256
85
            self.assertEqual(err.code, 2, "Invalid value passed")
257
86
        finally:
258
87
            sys.stderr = orig_stderr
259
88
        stderr.seek(0)
260
89
        self.assertIn("argument -n/--build-num: invalid int value: 'N'", 
261
90
                      stderr.read())
262
91
263
92
    def test_validate_args_run_none_values(self):
264
93
        orig_stderr = sys.stderr
265
94
        stderr = sys.stderr = StringIO()
266
95
        self.publisher = SnapshotsPublisher()
267
96
        try:
268
97
            param = self.parser.parse_args(['-t', None , '-r', None,  
269
98
                                            '-j', None , '-n' , 0])
270
99
            self.publisher.validate_args(param)
271
100
        except SystemExit, err:
272
101
            self.assertEqual(err.code, 2, "None values are not acceptable")
273
102
        finally:
274
103
            sys.stderr = orig_stderr
275
104
        stderr.seek(0)
276
105
        self.assertIn("You must specify job-type and job-name", 
277
106
                      stderr.read())
278
107
279
108
    def test_validate_paths_invalid_uploads_path(self):
280
109
        orig_stdout = sys.stdout
281
110
        stdout = sys.stdout = StringIO()
282
111
        self.publisher = SnapshotsPublisher()
283
112
        param = self.parser.parse_args(['-t', 'android', '-j', 'dummy_job_name', 
284
113
                                        '-n', '1'])
285
114
286
115
        self.publisher.validate_args(param)
287
116
        self.uploads_path = "./dummy_uploads_path"
288
117
        try:
289
118
            self.publisher.validate_paths(param, self.uploads_path, self.target_path)
290
119
        finally:
291
120
            sys.stdout = orig_stdout
292
121
        stdout.seek(0)
293
122
        self.assertIn("Missing build path", stdout.read())
294
123
295
124
    def test_validate_paths_invalid_target_path(self):
296
125
        orig_stdout = sys.stdout
297
126
        stdout = sys.stdout = StringIO()
298
127
        self.publisher = SnapshotsPublisher()
299
128
        param = self.parser.parse_args(['-t', 'android', '-j', 'dummy_job_name', 
300
129
                                        '-n', '1'])
301
130
302
131
        self.publisher.validate_args(param)
303
132
        self.target_path = "./dummy_target_path"
304
133
        try:
305
134
            self.publisher.validate_paths(param, self.uploads_path, 
306
135
                                                        self.target_path)
307
136
        finally:
308
137
            sys.stdout = orig_stdout
309
138
        stdout.seek(0)
310
139
        self.assertIn("Missing target path", stdout.read())
311
140
312
141
    def test_move_artifacts_kernel_successful_move(self):
313
142
        orig_stdout = sys.stdout
314
143
        stdout = sys.stdout = StringIO()
315
144
        self.publisher = SnapshotsPublisher()
316
145
        param = self.parser.parse_args(['-t', 'kernel-hwpack', '-j', 'dummy_job_name', 
317
146
                                        '-r', 'dummy_kernel_tree'])
318
147
        self.publisher.validate_args(param)
319
148
        build_path = os.path.join(self.uploads_path, param.job_type, param.kernel_tree, 
320
149
                                  param.job_name)
321
150
        os.makedirs(build_path)
322
151
        tempfiles = tempfile.mkstemp(dir=build_path)
323
152
        try:
324
153
            uploads_dir_path, target_dir_path = self.publisher.validate_paths(param, 
325
154
                                                self.uploads_path, self.target_path)
326
155
            self.publisher.move_artifacts(param, uploads_dir_path, target_dir_path)
327
156
        finally:
328
157
            sys.stdout = orig_stdout
329
158
            pass
330
159
         
331
160
        stdout.seek(0)
332
161
        self.assertIn("Moved the files from", stdout.read())
333
162
334
163
    def test_move_artifacts_android_successful_move(self):
335
164
        orig_stdout = sys.stdout
336
165
        stdout = sys.stdout = StringIO()
337
166
        self.publisher = SnapshotsPublisher()
338
167
        param = self.parser.parse_args(['-t', 'android', '-j', 'dummy_job_name', 
339
168
                                        '-n', '1'])
340
169
        self.publisher.validate_args(param)
341
170
        build_dir = '/'.join([param.job_type, param.job_name, str(param.build_num)])
342
171
        build_path = os.path.join(self.uploads_path, build_dir)
343
172
        os.makedirs(build_path)
344
173
        tempfiles = tempfile.mkstemp(dir=build_path)
345
174
        try:
346
175
            uploads_dir_path, target_dir_path = self.publisher.validate_paths(param, 
347
176
                                                self.uploads_path, self.target_path)
348
177
            self.publisher.move_artifacts(param, uploads_dir_path, target_dir_path)
349
178
        finally:
350
179
            sys.stdout = orig_stdout
351
180
            pass
352
181
         
353
182
        stdout.seek(0)
354
183
        self.assertIn("Moved the files from", stdout.read())
Status:	Merged
Merged at revision:	47
Proposed branch:	lp:~deeptik/linaro-license-protection/publish-to-snapshot
Merge into:	lp:~linaro-automation/linaro-license-protection/trunk
Diff against target:	354 lines (+330/-1) 3 files modified scripts/publish_to_snapshots.py (+142/-0) testing/__init__.py (+5/-1) testing/test_publish_to_snapshots.py (+183/-0)
To merge this branch:	bzr merge lp:~deeptik/linaro-license-protection/publish-to-snapshot
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Paul Sokolovsky		2012-03-09	Approve on 2012-03-14
Review via email: mp+96735@code.launchpad.net