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"), )