def test_found_values_used(self):
service = AWSCredentials(
environ={ENV_ACCESS_KEY: "foo", ENV_SECRET_KEY: "bar"},
)
self.assertEqual(
service, AWSCredentials(access_key="foo", secret_key="bar"),
)
def setUp(self):
self.credentials = AWSCredentials(
"access key id",
"secret access key",
)
self.agent = StubAgent()
self.now = datetime.utcfromtimestamp(1234567890)
def create_user_bucket(useraccesskeyid, usersecretkey, usertoken, bucketname, stdout, stderr,
producttoken=None, location=None):
if location is None:
print >>stdout, "Creating S3 bucket in 'US East' region..."
else:
# TODO: print user-friendly region name
print >>stdout, "Creating S3 bucket..."
print >>stderr, ('usertoken = %r\n'
'bucketname = %r\n'
'location = %r\n'
% (usertoken, bucketname, location))
usercreds = AWSCredentials(useraccesskeyid, usersecretkey)
client = DevPayS3Client(creds=usercreds, usertoken=usertoken, producttoken=producttoken)
if location:
object_name = "?LocationConstraint=" + urllib.quote(location)
else:
object_name = None
query = client.query_factory(
action="PUT", creds=client.creds, endpoint=client.endpoint,
bucket=bucketname, object_name=object_name)
d = query.submit()
def bucket_created(res):
print >>stdout, "S3 bucket created."
print >>stderr, repr(res)
d.addCallback(bucket_created)
return d
def test_handle_unicode_error(self):
"""
If an arbitrary error raised by an API method contains a unicode
message, L{QueryAPI} is able to protect itself from it.
"""
creds = AWSCredentials("access", "secret")
endpoint = AWSServiceEndpoint("http://uri")
query = Query(action="SomeAction", creds=creds, endpoint=endpoint)
query.sign()
request = FakeRequest(query.params, endpoint)
def fail_execute(call):
raise ValueError(u"\N{HIRAGANA LETTER A}dvanced")
self.api.execute = fail_execute
def check(ignored):
[error] = self.flushLoggedErrors()
self.assertIsInstance(error.value, ValueError)
self.assertTrue(request.finished)
self.assertEqual("Server error", request.response)
self.assertEqual(500, request.code)
self.api.principal = TestPrincipal(creds)
return self.api.handle(request).addCallback(check)
def test_handle_with_expired_signature(self):
"""
If the request contains an Expires parameter with a time that is before
the current time, an error is returned.
"""
creds = AWSCredentials("access", "secret")
endpoint = AWSServiceEndpoint("http://uri")
query = Query(action="SomeAction",
creds=creds,
endpoint=endpoint,
other_params={"Expires": "2010-01-01T12:00:00Z"})
query.sign()
request = FakeRequest(query.params, endpoint)
def check(ignored):
errors = self.flushLoggedErrors()
self.assertEquals(0, len(errors))
self.assertEqual(
"RequestExpired - Request has expired. Expires date is"
" 2010-01-01T12:00:00Z", request.response)
self.assertEqual(400, request.code)
now = datetime(2010, 1, 1, 12, 0, 1, tzinfo=tzutc())
self.api.get_utc_time = lambda: now
return self.api.handle(request).addCallback(check)
def test_delete_object(self):
class StubQuery(client.Query):
def __init__(query,
action,
creds,
endpoint,
bucket=None,
object_name=None,
data=None,
content_type=None,
metadata=None):
super(StubQuery, query).__init__(action=action,
creds=creds,
bucket=bucket,
object_name=object_name,
data=data,
content_type=content_type,
metadata=metadata)
self.assertEqual(action, "DELETE")
self.assertEqual(creds.access_key, "foo")
self.assertEqual(creds.secret_key, "bar")
self.assertEqual(query.bucket, "mybucket")
self.assertEqual(query.object_name, "objectname")
def submit(query):
return succeed(None)
creds = AWSCredentials("foo", "bar")
s3 = client.S3Client(creds, query_factory=StubQuery)
return s3.delete_object("mybucket", "objectname")
def test_handle_with_timestamp_and_expires(self):
"""
If the request contains both Expires and Timestamp parameters,
an error is returned.
"""
creds = AWSCredentials("access", "secret")
endpoint = AWSServiceEndpoint("http://uri")
query = Query(action="SomeAction",
creds=creds,
endpoint=endpoint,
other_params={
"Timestamp": "2010-01-01T12:00:00Z",
"Expires": "2010-01-01T12:00:00Z"
})
query.sign()
request = FakeRequest(query.params, endpoint)
def check(ignored):
errors = self.flushLoggedErrors()
self.assertEquals(0, len(errors))
self.assertEqual(
"InvalidParameterCombination - The parameter Timestamp"
" cannot be used with the parameter Expires", request.response)
self.assertEqual(400, request.code)
return self.api.handle(request).addCallback(check)
def test_retry_on_failure(self, access_key_id, secret_key, bucket_name):
"""
If bucket creation fails with an S3 error, the creation attempt is
retried after a delay.
"""
reactor = Clock()
controller = MemoryS3()
creds = AWSCredentials(access_key_id, secret_key)
client, state = controller.client(creds=creds, endpoint=None)
state.set_rate_limit_exceeded()
d = create_user_bucket(reactor, client, bucket_name)
# Let several minutes pass (in one second increments) while
# the rate limit error is in place.
reactor.pump([1] * 60 * 3)
# It should still be retrying.
self.assertNoResult(d)
# Clear the rate limit error and let it try again.
state.clear_rate_limit_exceeded()
reactor.pump([1] * 60)
# It should have met with success at this point.
self.assertThat(self.successResultOf(d), Is(None))
def test_get_object_acl(self):
class StubQuery(client.Query):
def __init__(query, action, creds, endpoint, bucket=None,
object_name=None, data=""):
super(StubQuery, query).__init__(action=action, creds=creds,
bucket=bucket,
object_name=object_name,
data=data)
self.assertEquals(action, "GET")
self.assertEqual(creds.access_key, "foo")
self.assertEqual(creds.secret_key, "bar")
self.assertEqual(query.bucket, "mybucket")
self.assertEqual(query.object_name, "myobject?acl")
self.assertEqual(query.data, "")
self.assertEqual(query.metadata, {})
def submit(query, url_context=None):
return succeed(payload.sample_access_control_policy_result)
def check_result(result):
self.assert_(isinstance(result, AccessControlPolicy))
creds = AWSCredentials("foo", "bar")
s3 = client.S3Client(creds, query_factory=StubQuery)
deferred = s3.get_object_acl("mybucket", "myobject")
return deferred.addCallback(check_result)
def test_list_buckets(self):
class StubQuery(client.Query):
def __init__(query, action, creds, endpoint):
super(StubQuery, query).__init__(
action=action, creds=creds)
self.assertEquals(action, "GET")
self.assertEqual(creds.access_key, "foo")
self.assertEqual(creds.secret_key, "bar")
self.assertEqual(query.bucket, None)
self.assertEqual(query.object_name, None)
self.assertEqual(query.data, "")
self.assertEqual(query.metadata, {})
def submit(query):
return succeed(payload.sample_list_buckets_result)
def check_list_buckets(results):
bucket1, bucket2 = results
self.assertEquals(bucket1.name, "quotes")
self.assertEquals(
bucket1.creation_date.timetuple(),
(2006, 2, 3, 16, 45, 9, 4, 34, 0))
self.assertEquals(bucket2.name, "samples")
self.assertEquals(
bucket2.creation_date.timetuple(),
(2006, 2, 3, 16, 41, 58, 4, 34, 0))
creds = AWSCredentials("foo", "bar")
s3 = client.S3Client(creds, query_factory=StubQuery)
d = s3.list_buckets()
return d.addCallback(check_list_buckets)
def test_put_object(self):
class StubQuery(client.Query):
def __init__(query, action, creds, endpoint, bucket=None,
object_name=None, data=None, content_type=None,
metadata=None, amz_headers=None):
super(StubQuery, query).__init__(
action=action, creds=creds, bucket=bucket,
object_name=object_name, data=data,
content_type=content_type, metadata=metadata,
amz_headers=amz_headers)
self.assertEqual(action, "PUT")
self.assertEqual(creds.access_key, "foo")
self.assertEqual(creds.secret_key, "bar")
self.assertEqual(query.bucket, "mybucket")
self.assertEqual(query.object_name, "objectname")
self.assertEqual(query.data, "some data")
self.assertEqual(query.content_type, "text/plain")
self.assertEqual(query.metadata, {"key": "some meta data"})
self.assertEqual(query.amz_headers, {"acl": "public-read"})
def submit(query):
return succeed(None)
creds = AWSCredentials("foo", "bar")
s3 = client.S3Client(creds, query_factory=StubQuery)
return s3.put_object("mybucket", "objectname", "some data",
content_type="text/plain",
metadata={"key": "some meta data"},
amz_headers={"acl": "public-read"})
def test_copy_object(self):
"""
L{S3Client.copy_object} creates a L{Query} to copy an object from one
bucket to another.
"""
class StubQuery(client.Query):
def __init__(query, action, creds, endpoint, bucket=None,
object_name=None, data=None, content_type=None,
metadata=None, amz_headers=None):
super(StubQuery, query).__init__(
action=action, creds=creds, bucket=bucket,
object_name=object_name, data=data,
content_type=content_type, metadata=metadata,
amz_headers=amz_headers)
self.assertEqual(action, "PUT")
self.assertEqual(creds.access_key, "foo")
self.assertEqual(creds.secret_key, "bar")
self.assertEqual(query.bucket, "newbucket")
self.assertEqual(query.object_name, "newobjectname")
self.assertEqual(query.data, None)
self.assertEqual(query.content_type, None)
self.assertEqual(query.metadata, {"key": "some meta data"})
self.assertEqual(query.amz_headers,
{"copy-source": "/mybucket/objectname"})
def submit(query):
return succeed(None)
creds = AWSCredentials("foo", "bar")
s3 = client.S3Client(creds, query_factory=StubQuery)
return s3.copy_object("mybucket", "objectname", "newbucket",
"newobjectname",
metadata={"key": "some meta data"})
def test_put_request_payment(self):
"""
L{S3Client.put_request_payment} creates a L{Query} to set payment
information. An C{RequestPaymentConfiguration} XML document is built
and sent to the endpoint and a C{Deferred} is returned that fires with
the results of the request.
"""
class StubQuery(client.Query):
def __init__(query, action, creds, endpoint, bucket=None,
object_name=None, data=None, content_type=None,
metadata=None):
super(StubQuery, query).__init__(
action=action, creds=creds, bucket=bucket,
object_name=object_name, data=data,
content_type=content_type, metadata=metadata)
self.assertEqual(action, "PUT")
self.assertEqual(creds.access_key, "foo")
self.assertEqual(creds.secret_key, "bar")
self.assertEqual(query.bucket, "mybucket")
self.assertEqual(query.object_name, "?requestPayment")
xml = ("<RequestPaymentConfiguration "
'xmlns="http://s3.amazonaws.com/doc/2006-03-01/">\n'
" <Payer>Requester</Payer>\n"
"</RequestPaymentConfiguration>")
self.assertEqual(query.data, xml)
self.assertEqual(query.metadata, None)
def submit(query):
return succeed(None)
creds = AWSCredentials("foo", "bar")
s3 = client.S3Client(creds, query_factory=StubQuery)
return s3.put_request_payment("mybucket", "Requester")
def test_get_request_payment(self):
"""
L{S3Client.get_request_payment} creates a L{Query} to get payment
information. It parses the returned C{RequestPaymentConfiguration}
XML document and returns a C{Deferred} that fires with the payer's
name.
"""
class StubQuery(client.Query):
def __init__(query, action, creds, endpoint, bucket=None,
object_name=None, data=None, content_type=None,
metadata=None):
super(StubQuery, query).__init__(
action=action, creds=creds, bucket=bucket,
object_name=object_name, data=data,
content_type=content_type, metadata=metadata)
self.assertEqual(action, "GET")
self.assertEqual(creds.access_key, "foo")
self.assertEqual(creds.secret_key, "bar")
self.assertEqual(query.bucket, "mybucket")
self.assertEqual(query.object_name, "?requestPayment")
self.assertEqual(query.metadata, None)
def submit(query):
return succeed(payload.sample_request_payment)
def check_request_payment(result):
self.assertEquals(result, "Requester")
creds = AWSCredentials("foo", "bar")
s3 = client.S3Client(creds, query_factory=StubQuery)
deferred = s3.get_request_payment("mybucket")
return deferred.addCallback(check_request_payment)
def setUp(self):
self._time_patcher = mock.patch('time.time')
nowfunc = self._time_patcher.__enter__()
nowfunc.return_value = self.SOME_TIME
self._http_patcher = mock.patch(
'lae_automation.aws.queryapi.make_http_request')
self._make_http_request = self._http_patcher.__enter__()
def fire_mocked_http_response(*a, **kw):
d = Deferred()
reactor.callLater(0, d.callback, SAMPLE_RESPONSE)
return d
self._make_http_request.side_effect = fire_mocked_http_response
self._trimmed_fake_params = dict(FAKE_PARAMS)
# Remove these params which are automatically added in _build_request_uri:
del self._trimmed_fake_params['AWSAccessKeyId']
del self._trimmed_fake_params['Expires']
del self._trimmed_fake_params['SignatureVersion']
del self._trimmed_fake_params['Version']
self.lsc = LicenseServiceClient(creds=AWSCredentials(
access_key=FAKE_AWS_ACCESS_KEY_ID, secret_key=FAKE_HMAC_KEY), )
def test_get_bucket_location(self):
"""
L{S3Client.get_bucket_location} creates a L{Query} to get a bucket's
location. It parses the returned C{LocationConstraint} XML document
and returns a C{Deferred} that fires with the bucket's region.
"""
class StubQuery(client.Query):
def __init__(query, action, creds, endpoint, bucket=None,
object_name=None):
super(StubQuery, query).__init__(action=action, creds=creds,
bucket=bucket,
object_name=object_name)
self.assertEquals(action, "GET")
self.assertEqual(creds.access_key, "foo")
self.assertEqual(creds.secret_key, "bar")
self.assertEqual(query.bucket, "mybucket")
self.assertEqual(query.object_name, "?location")
self.assertEqual(query.data, "")
self.assertEqual(query.metadata, {})
self.assertEqual(query.amz_headers, {})
def submit(query, url_context=None):
return succeed(payload.sample_get_bucket_location_result)
def check_results(location_constraint):
self.assertEquals(location_constraint, "EU")
creds = AWSCredentials("foo", "bar")
s3 = client.S3Client(creds, query_factory=StubQuery)
d = s3.get_bucket_location("mybucket")
return d.addCallback(check_results)
def __init__(self,
access_key="",
secret_key="",
uri="",
ec2_client_factory=None,
keypairs=None,
security_groups=None,
instances=None,
volumes=None,
snapshots=None,
availability_zones=None):
self.access_key = access_key
self.secret_key = secret_key
self.uri = uri
self.ec2_client = None
if not ec2_client_factory:
ec2_client_factory = FakeEC2Client
self.ec2_client_factory = ec2_client_factory
self.keypairs = keypairs
self.security_groups = security_groups
self.instances = instances
self.volumes = volumes
self.snapshots = snapshots
self.availability_zones = availability_zones
self.s3 = MemoryS3()
self._creds = AWSCredentials(
access_key=self.access_key,
secret_key=self.secret_key,
)
self._endpoint = AWSServiceEndpoint(uri=self.uri)
self._route53_controller = MemoryRoute53()
def test_handle_unicode_api_error(self):
"""
If an L{APIError} contains a unicode message, L{QueryAPI} is able to
protect itself from it.
"""
creds = AWSCredentials("access", "secret")
endpoint = AWSServiceEndpoint("http://uri")
query = Query(action="SomeAction", creds=creds, endpoint=endpoint)
query.sign()
request = FakeRequest(query.params, endpoint)
def fail_execute(call):
raise APIError(400,
code="LangError",
message=u"\N{HIRAGANA LETTER A}dvanced")
self.api.execute = fail_execute
def check(ignored):
errors = self.flushLoggedErrors()
self.assertEquals(0, len(errors))
self.assertTrue(request.finished)
self.assertTrue(request.response.startswith("LangError"))
self.assertEqual(400, request.code)
self.api.principal = TestPrincipal(creds)
return self.api.handle(request).addCallback(check)
def test_handle_500_api_error(self):
"""
If an L{APIError} is raised with a status code superior or equal to
500, the error is logged on the server side.
"""
creds = AWSCredentials("access", "secret")
endpoint = AWSServiceEndpoint("http://uri")
query = Query(action="SomeAction", creds=creds, endpoint=endpoint)
query.sign()
request = FakeRequest(query.params, endpoint)
def fail_execute(call):
raise APIError(500, response="oops")
self.api.execute = fail_execute
def check(ignored):
errors = self.flushLoggedErrors()
self.assertEquals(1, len(errors))
self.assertTrue(request.finished)
self.assertEqual("oops", request.response)
self.assertEqual(500, request.code)
self.api.principal = TestPrincipal(creds)
return self.api.handle(request).addCallback(check)
def test_handle_pass_params_to_call(self):
"""
L{QueryAPI.handle} creates a L{Call} object with the correct
parameters.
"""
self.registry.add(TestMethod, "SomeAction", "1.2.3")
creds = AWSCredentials("access", "secret")
endpoint = AWSServiceEndpoint("http://uri")
query = Query(action="SomeAction",
creds=creds,
endpoint=endpoint,
other_params={
"Foo": "bar",
"Version": "1.2.3"
})
query.sign()
request = FakeRequest(query.params, endpoint)
def execute(call):
self.assertEqual({"Foo": "bar"}, call.get_raw_params())
self.assertIdentical(self.api.principal, call.principal)
self.assertEqual("SomeAction", call.action)
self.assertEqual("1.2.3", call.version)
self.assertEqual(request.id, call.id)
return "ok"
def check(ignored):
self.assertEqual("ok", request.response)
self.assertEqual(200, request.code)
self.api.execute = execute
self.api.principal = TestPrincipal(creds)
return self.api.handle(request).addCallback(check)
def test_handle_custom_get_call_arguments(self):
"""
L{QueryAPI.handle} uses L{QueryAPI.get_call_arguments} to get the
arguments for a call.
"""
creds = AWSCredentials("access", "secret")
endpoint = AWSServiceEndpoint("http://uri")
api = AlternativeWireFormatQueryAPI(self.registry)
params = {"foo": "bar", "access_key": creds.access_key}
signature = Signature(creds,
endpoint,
params.copy(),
signature_method="Hmacsha256",
signature_version=2)
params["signature"] = signature.compute()
request = FakeRequest(params, endpoint)
def check(ignored):
self.assertTrue(request.finished)
self.assertEqual("data", request.response)
self.assertEqual("4", request.headers["Content-Length"])
self.assertEqual("text/plain", request.headers["Content-Type"])
self.assertEqual(200, request.code)
api.principal = TestPrincipal(creds)
return api.handle(request).addCallback(check)
def credentials(self, *a, **kw):
"""
Construct an L{AWSCredentials} instance with the given parameters but
pointing at C{self.credentials_path} instead of the default
credentials file.
"""
kw["environ"] = self.environ(kw.get("environ", {}))
return AWSCredentials(*a, **kw)
def _getClient(self):
"""
Build a txAWS S3 client using our stored credentials.
"""
creds = AWSCredentials(access_key=self.accessKey.encode('utf-8'),
secret_key=self.secretKey.encode('utf-8'))
region = AWSServiceRegion(creds=creds)
return region.get_s3_client()
def __init__(self, creds=None, endpoint=None, query_factory=None):
if creds is None:
creds = AWSCredentials()
if endpoint is None:
endpoint = AWSServiceEndpoint()
self.creds = creds
self.endpoint = endpoint
self.query_factory = query_factory
def test_explicit_secret_key(self):
service = self.credentials(
secret_key="bar",
environ={ENV_ACCESS_KEY: "foo"},
)
self.assertEqual(
service, AWSCredentials(access_key="foo", secret_key="bar"),
)
def test_nondefault_endpoint(self):
lsc = LicenseServiceClient(
creds=AWSCredentials(access_key=FAKE_AWS_ACCESS_KEY_ID,
secret_key=FAKE_HMAC_KEY),
endpoint=AWSServiceEndpoint(
uri=PRODUCTION_LICENSE_SERVICE_ENDPOINT),
)
self.failUnlessEqual(vars(lsc._endpoint), vars(self.lsc._endpoint))
def get_route53_client(self, creds=None):
if creds is None:
creds = AWSCredentials(
access_key=self.access_key,
secret_key=self.secret_key,
)
endpoint = AWSServiceEndpoint(uri=self.uri)
client, state = self._route53_controller.client(creds, endpoint)
return client
def get_s3_client(self, creds=None):
if creds is None:
creds = AWSCredentials(
access_key=self.access_key,
secret_key=self.secret_key,
)
endpoint = AWSServiceEndpoint(uri=self.uri)
self.s3_client, self.s3_state = self.s3.client(creds, endpoint)
return self.s3_client
def __init__(self, reactor):
# Even though we have appindicator, we may still need the status
# icon because we're on something that does not show them.
self.status_icon = gtk.StatusIcon()
self.status_icon.set_from_stock(gtk.STOCK_NETWORK)
self.status_icon.set_visible(True)
self.status_icon.connect("activate", self.on_activate)
if have_appindicator:
self.indicator = appindicator.Indicator(
"aws-status", "stock_weather-cloudy",
appindicator.CATEGORY_OTHER)
self.indicator.set_status(appindicator.STATUS_PASSIVE)
self.reactor = reactor
self.probing = False
# Nested import because otherwise we get "reactor already installed".
self.password_dialog = None
self.region = None
try:
creds = AWSCredentials()
except ValueError:
creds = self.from_gnomekeyring()
if self.region is None:
self.set_region(creds)
self.create_client(creds)
menu = """
<ui>
<menubar name="Menubar">
<menu action="Menu">
<menuitem action="Refresh"/>
<menuitem action="Stop instances"/>
<menuitem action="Quit"/>
</menu>
</menubar>
</ui>
"""
actions = [
("Menu", None, "Menu"),
("Refresh", gtk.STOCK_REFRESH, "_Refresh...", None, "Refresh",
self.on_activate),
("Stop instances", gtk.STOCK_STOP, "_Stop instances...", None,
"Stop instances", self.on_stop_instances),
("Quit", gtk.STOCK_QUIT, "_Quit...", None, "Quit", self.on_quit),
]
ag = gtk.ActionGroup("Actions")
ag.add_actions(actions)
self.manager = gtk.UIManager()
self.manager.insert_action_group(ag, 0)
self.manager.add_ui_from_string(menu)
self.menu = self.manager.get_widget(
"/Menubar/Menu/Stop instances").props.parent
self.status_icon.connect("popup-menu", self.on_popup_menu)
if have_appindicator:
self.indicator.set_menu(self.menu)
# kickstart things
self.on_activate(None)
self.queue_check()
def test_explicit_shared_credentials_file(self):
with open(self.mktemp(), "w") as credentials_file:
credentials_file.write(
dedent(
"""
[default]
aws_access_key_id = foo
aws_secret_access_key = bar
"""
),
)
# Construct AWSCredentials here instead of using the self.credentials
# helper because we're interested in testing exactly what happens when
# this env var is set.
service = AWSCredentials(
environ={ENV_SHARED_CREDENTIALS_FILE: credentials_file.name},
)
self.assertEqual(
service, AWSCredentials(access_key="foo", secret_key="bar"),
)