idx
int64 0
241k
| question
stringlengths 64
6.21k
| target
stringlengths 5
803
|
|---|---|---|
0
|
public function onChannelPreDelete ( ResourceControllerEvent $ event ) : void { $ channel = $ event -> getSubject ( ) ; if ( ! $ channel instanceof ChannelInterface ) { throw new UnexpectedTypeException ( $ channel , ChannelInterface :: class ) ; } $ results = $ this -> channelRepository -> findBy ( [ 'enabled' => true ] ) ; if ( ! $ results || ( count ( $ results ) === 1 && current ( $ results ) === $ channel ) ) { $ event -> stop ( 'sylius.channel.delete_error' ) ; } }
|
Prevent channel deletion if no more channels enabled .
|
1
|
public function getTaxTotal ( ) : int { $ taxTotal = 0 ; foreach ( $ this -> getAdjustments ( AdjustmentInterface :: TAX_ADJUSTMENT ) as $ taxAdjustment ) { $ taxTotal += $ taxAdjustment -> getAmount ( ) ; } foreach ( $ this -> units as $ unit ) { $ taxTotal += $ unit -> getTaxTotal ( ) ; } return $ taxTotal ; }
|
Returns sum of neutral and non neutral tax adjustments on order item and total tax of units .
|
2
|
private function isLastEnabledEntity ( $ result , $ entity ) : bool { return ! $ result || 0 === count ( $ result ) || ( 1 === count ( $ result ) && $ entity === ( $ result instanceof \ Iterator ? $ result -> current ( ) : current ( $ result ) ) ) ; }
|
If no entity matched the query criteria or a single entity matched which is the same as the entity being validated the entity is the last enabled entity available .
|
3
|
protected function recalculateTotal ( ) : void { $ this -> total = $ this -> itemsTotal + $ this -> adjustmentsTotal ; if ( $ this -> total < 0 ) { $ this -> total = 0 ; } }
|
Items total + Adjustments total .
|
4
|
public function loginAction ( Request $ request ) : Response { $ authenticationUtils = $ this -> get ( 'security.authentication_utils' ) ; $ error = $ authenticationUtils -> getLastAuthenticationError ( ) ; $ lastUsername = $ authenticationUtils -> getLastUsername ( ) ; $ options = $ request -> attributes -> get ( '_sylius' ) ; $ template = $ options [ 'template' ] ?? null ; Assert :: notNull ( $ template , 'Template is not configured.' ) ; $ formType = $ options [ 'form' ] ?? UserLoginType :: class ; $ form = $ this -> get ( 'form.factory' ) -> createNamed ( '' , $ formType ) ; return $ this -> render ( $ template , [ 'form' => $ form -> createView ( ) , 'last_username' => $ lastUsername , 'error' => $ error , ] ) ; }
|
Login form action .
|
5
|
public function getTaxTotal ( ) : int { $ taxTotal = 0 ; foreach ( $ this -> getAdjustments ( AdjustmentInterface :: TAX_ADJUSTMENT ) as $ taxAdjustment ) { $ taxTotal += $ taxAdjustment -> getAmount ( ) ; } foreach ( $ this -> items as $ item ) { $ taxTotal += $ item -> getTaxTotal ( ) ; } return $ taxTotal ; }
|
Returns sum of neutral and non neutral tax adjustments on order and total tax of order items .
|
6
|
public function getShippingTotal ( ) : int { $ shippingTotal = $ this -> getAdjustmentsTotal ( AdjustmentInterface :: SHIPPING_ADJUSTMENT ) ; $ shippingTotal += $ this -> getAdjustmentsTotal ( AdjustmentInterface :: ORDER_SHIPPING_PROMOTION_ADJUSTMENT ) ; $ shippingTotal += $ this -> getAdjustmentsTotal ( AdjustmentInterface :: TAX_ADJUSTMENT ) ; return $ shippingTotal ; }
|
Returns shipping fee together with taxes decreased by shipping discount .
|
7
|
public function getOrderPromotionTotal ( ) : int { $ orderPromotionTotal = 0 ; foreach ( $ this -> items as $ item ) { $ orderPromotionTotal += $ item -> getAdjustmentsTotalRecursively ( AdjustmentInterface :: ORDER_PROMOTION_ADJUSTMENT ) ; } return $ orderPromotionTotal ; }
|
Returns amount of order discount . Does not include order item and shipping discounts .
|
8
|
protected function recalculateTotal ( ) : void { $ this -> total = $ this -> unitsTotal + $ this -> adjustmentsTotal ; if ( $ this -> total < 0 ) { $ this -> total = 0 ; } if ( null !== $ this -> order ) { $ this -> order -> recalculateItemsTotal ( ) ; } }
|
Recalculates total after units total or adjustments total change .
|
9
|
private function updateUserByOAuthUserResponse ( UserInterface $ user , UserResponseInterface $ response ) : SyliusUserInterface { Assert :: isInstanceOf ( $ user , SyliusUserInterface :: class ) ; $ oauth = $ this -> oauthFactory -> createNew ( ) ; $ oauth -> setIdentifier ( $ response -> getUsername ( ) ) ; $ oauth -> setProvider ( $ response -> getResourceOwner ( ) -> getName ( ) ) ; $ oauth -> setAccessToken ( $ response -> getAccessToken ( ) ) ; $ oauth -> setRefreshToken ( $ response -> getRefreshToken ( ) ) ; $ user -> addOAuthAccount ( $ oauth ) ; $ this -> userManager -> persist ( $ user ) ; $ this -> userManager -> flush ( ) ; return $ user ; }
|
Attach OAuth sign - in provider account to existing user .
|
10
|
public function serialize ( ) : string { return serialize ( [ $ this -> password , $ this -> salt , $ this -> usernameCanonical , $ this -> username , $ this -> locked , $ this -> enabled , $ this -> id , $ this -> encoderName , ] ) ; }
|
The serialized data have to contain the fields used by the equals method and the username .
|
11
|
public static function wrap ( callable $ credentialProvider , $ options , $ region , $ service ) { return function ( callable $ handler ) use ( $ credentialProvider , $ options , $ region , $ service ) { return new static ( $ handler , $ credentialProvider , $ options , $ region , $ service ) ; } ; }
|
Standard middleware wrapper function with CSM options passed in .
|
12
|
public function getOperationDocs ( $ operation ) { return isset ( $ this -> docs [ 'operations' ] [ $ operation ] ) ? $ this -> docs [ 'operations' ] [ $ operation ] : null ; }
|
Retrieves documentation about an operation .
|
13
|
public function getErrorDocs ( $ error ) { return isset ( $ this -> docs [ 'shapes' ] [ $ error ] [ 'base' ] ) ? $ this -> docs [ 'shapes' ] [ $ error ] [ 'base' ] : null ; }
|
Retrieves documentation about an error .
|
14
|
public function getShapeDocs ( $ shapeName , $ parentName , $ ref ) { if ( ! isset ( $ this -> docs [ 'shapes' ] [ $ shapeName ] ) ) { return '' ; } $ result = '' ; $ d = $ this -> docs [ 'shapes' ] [ $ shapeName ] ; if ( isset ( $ d [ 'refs' ] [ "{$parentName}\$${ref}" ] ) ) { $ result = $ d [ 'refs' ] [ "{$parentName}\$${ref}" ] ; } elseif ( isset ( $ d [ 'base' ] ) ) { $ result = $ d [ 'base' ] ; } if ( isset ( $ d [ 'append' ] ) ) { $ result .= $ d [ 'append' ] ; } return $ this -> clean ( $ result ) ; }
|
Retrieves documentation about a shape specific to the context .
|
15
|
public function createToken ( $ endpoint , $ region , $ username ) { $ uri = new Uri ( $ endpoint ) ; $ uri = $ uri -> withPath ( '/' ) ; $ uri = $ uri -> withQuery ( 'Action=connect&DBUser=' . $ username ) ; $ request = new Request ( 'GET' , $ uri ) ; $ signer = new SignatureV4 ( 'rds-db' , $ region ) ; $ provider = $ this -> credentialProvider ; $ url = ( string ) $ signer -> presign ( $ request , $ provider ( ) -> wait ( ) , '+15 minutes' ) -> getUri ( ) ; return substr ( $ url , 2 ) ; }
|
Create the token for database login
|
16
|
public static function resolve ( callable $ provider , array $ args = [ ] ) { $ result = $ provider ( $ args ) ; if ( is_array ( $ result ) ) { return $ result ; } throw new UnresolvedEndpointException ( 'Unable to resolve an endpoint using the provider arguments: ' . json_encode ( $ args ) . '. Note: you can provide an "endpoint" ' . 'option to a client constructor to bypass invoking an endpoint ' . 'provider.' ) ; }
|
Resolves and endpoint provider and ensures a non - null return value .
|
17
|
public static function wrap ( $ region , array $ options ) { return function ( callable $ handler ) use ( $ region , $ options ) { return new self ( $ handler , $ region , $ options ) ; } ; }
|
Create a middleware wrapper function
|
18
|
public function save ( MetadataEnvelope $ envelope , array $ args ) { $ this -> client -> putObject ( [ 'Bucket' => $ args [ 'Bucket' ] , 'Key' => $ args [ 'Key' ] . $ this -> suffix , 'Body' => json_encode ( $ envelope ) ] ) ; return $ args ; }
|
Places the information in the MetadataEnvelope to a location on S3 .
|
19
|
public function load ( array $ args ) { $ result = $ this -> client -> getObject ( [ 'Bucket' => $ args [ 'Bucket' ] , 'Key' => $ args [ 'Key' ] . $ this -> suffix ] ) ; $ metadataHeaders = json_decode ( $ result [ 'Body' ] , true ) ; $ envelope = new MetadataEnvelope ( ) ; $ constantValues = MetadataEnvelope :: getConstantValues ( ) ; foreach ( $ constantValues as $ constant ) { if ( ! empty ( $ metadataHeaders [ $ constant ] ) ) { $ envelope [ $ constant ] = $ metadataHeaders [ $ constant ] ; } } return $ envelope ; }
|
Uses the strategy s client to retrieve the instruction file from S3 and generates a MetadataEnvelope from its contents .
|
20
|
public static function createSerializer ( Service $ api , $ endpoint ) { static $ mapping = [ 'json' => 'Aws\Api\Serializer\JsonRpcSerializer' , 'query' => 'Aws\Api\Serializer\QuerySerializer' , 'rest-json' => 'Aws\Api\Serializer\RestJsonSerializer' , 'rest-xml' => 'Aws\Api\Serializer\RestXmlSerializer' ] ; $ proto = $ api -> getProtocol ( ) ; if ( isset ( $ mapping [ $ proto ] ) ) { return new $ mapping [ $ proto ] ( $ api , $ endpoint ) ; } if ( $ proto == 'ec2' ) { return new QuerySerializer ( $ api , $ endpoint , new Ec2ParamBuilder ( ) ) ; } throw new \ UnexpectedValueException ( 'Unknown protocol: ' . $ api -> getProtocol ( ) ) ; }
|
Creates a request serializer for the provided API object .
|
21
|
public function getOperation ( $ name ) { if ( ! isset ( $ this -> operations [ $ name ] ) ) { if ( ! isset ( $ this -> definition [ 'operations' ] [ $ name ] ) ) { throw new \ InvalidArgumentException ( "Unknown operation: $name" ) ; } $ this -> operations [ $ name ] = new Operation ( $ this -> definition [ 'operations' ] [ $ name ] , $ this -> shapeMap ) ; } return $ this -> operations [ $ name ] ; }
|
Get an operation by name .
|
22
|
public function getOperations ( ) { $ result = [ ] ; foreach ( $ this -> definition [ 'operations' ] as $ name => $ definition ) { $ result [ $ name ] = $ this -> getOperation ( $ name ) ; } return $ result ; }
|
Get all of the operations of the description .
|
23
|
public function getMetadata ( $ key = null ) { if ( ! $ key ) { return $ this [ 'metadata' ] ; } if ( isset ( $ this -> definition [ 'metadata' ] [ $ key ] ) ) { return $ this -> definition [ 'metadata' ] [ $ key ] ; } return null ; }
|
Get all of the service metadata or a specific metadata key value .
|
24
|
public function getPaginators ( ) { if ( ! isset ( $ this -> paginators ) ) { $ res = call_user_func ( $ this -> apiProvider , 'paginator' , $ this -> serviceName , $ this -> apiVersion ) ; $ this -> paginators = isset ( $ res [ 'pagination' ] ) ? $ res [ 'pagination' ] : [ ] ; } return $ this -> paginators ; }
|
Gets an associative array of available paginator configurations where the key is the name of the paginator and the value is the paginator configuration .
|
25
|
public function getPaginatorConfig ( $ name ) { static $ defaults = [ 'input_token' => null , 'output_token' => null , 'limit_key' => null , 'result_key' => null , 'more_results' => null , ] ; if ( $ this -> hasPaginator ( $ name ) ) { return $ this -> paginators [ $ name ] + $ defaults ; } throw new \ UnexpectedValueException ( "There is no {$name} " . "paginator defined for the {$this->serviceName} service." ) ; }
|
Retrieve a paginator by name .
|
26
|
public function getWaiters ( ) { if ( ! isset ( $ this -> waiters ) ) { $ res = call_user_func ( $ this -> apiProvider , 'waiter' , $ this -> serviceName , $ this -> apiVersion ) ; $ this -> waiters = isset ( $ res [ 'waiters' ] ) ? $ res [ 'waiters' ] : [ ] ; } return $ this -> waiters ; }
|
Gets an associative array of available waiter configurations where the key is the name of the waiter and the value is the waiter configuration .
|
27
|
public function addChecksum ( $ checksum , $ inBinaryForm = false ) { if ( $ this -> hash ) { throw new \ LogicException ( 'You may not add more checksums to a ' . 'complete tree hash.' ) ; } $ this -> checksums [ ] = $ inBinaryForm ? $ checksum : hex2bin ( $ checksum ) ; return $ this ; }
|
Add a checksum to the tree hash directly
|
28
|
private function getChecksumsMiddleware ( ) { return function ( callable $ handler ) { return function ( CommandInterface $ command , RequestInterface $ request = null ) use ( $ handler ) { if ( ! $ command [ 'ContentSHA256' ] && $ command [ 'contentSHA256' ] ) { $ command [ 'ContentSHA256' ] = $ command [ 'contentSHA256' ] ; unset ( $ command [ 'contentSHA256' ] ) ; } $ name = $ command -> getName ( ) ; if ( ( $ name === 'UploadArchive' || $ name === 'UploadMultipartPart' ) && ( ! $ command [ 'checksum' ] || ! $ command [ 'ContentSHA256' ] ) ) { $ body = $ request -> getBody ( ) ; if ( ! $ body -> isSeekable ( ) ) { throw new CouldNotCreateChecksumException ( 'sha256' ) ; } if ( ! $ command [ 'checksum' ] ) { $ body = new HashingStream ( $ body , new TreeHash ( ) , function ( $ result ) use ( $ command , & $ request ) { $ request = $ request -> withHeader ( 'x-amz-sha256-tree-hash' , bin2hex ( $ result ) ) ; } ) ; } if ( ! $ command [ 'ContentSHA256' ] ) { $ body = new HashingStream ( $ body , new PhpHash ( 'sha256' ) , function ( $ result ) use ( $ command ) { $ command [ 'ContentSHA256' ] = bin2hex ( $ result ) ; } ) ; } while ( ! $ body -> eof ( ) ) { $ body -> read ( 1048576 ) ; } $ body -> seek ( 0 ) ; } if ( $ command [ 'ContentSHA256' ] ) { $ request = $ request -> withHeader ( 'x-amz-content-sha256' , $ command [ 'ContentSHA256' ] ) ; } return $ handler ( $ command , $ request ) ; } ; } ; }
|
Creates a middleware that updates a command with the content and tree hash headers for upload operations .
|
29
|
private function getApiVersionMiddleware ( ) { return function ( callable $ handler ) { return function ( CommandInterface $ command , RequestInterface $ request = null ) use ( $ handler ) { return $ handler ( $ command , $ request -> withHeader ( 'x-amz-glacier-version' , $ this -> getApi ( ) -> getMetadata ( 'apiVersion' ) ) ) ; } ; } ; }
|
Creates a middleware that adds the API version header for all requests .
|
30
|
public function getDefaultCurlOptionsMiddleware ( ) { return Middleware :: mapCommand ( function ( CommandInterface $ cmd ) { $ defaultCurlOptions = [ CURLOPT_TCP_KEEPALIVE => 1 , ] ; if ( ! isset ( $ cmd [ '@http' ] [ 'curl' ] ) ) { $ cmd [ '@http' ] [ 'curl' ] = $ defaultCurlOptions ; } else { $ cmd [ '@http' ] [ 'curl' ] += $ defaultCurlOptions ; } return $ cmd ; } ) ; }
|
Provides a middleware that sets default Curl options for the command
|
31
|
public static function chain ( ) { $ links = func_get_args ( ) ; if ( empty ( $ links ) ) { throw new \ InvalidArgumentException ( 'No providers in chain' ) ; } return function ( ) use ( $ links ) { $ parent = array_shift ( $ links ) ; $ promise = $ parent ( ) ; while ( $ next = array_shift ( $ links ) ) { $ promise = $ promise -> otherwise ( $ next ) ; } return $ promise ; } ; }
|
Creates an aggregate credentials provider that invokes the provided variadic providers one after the other until a provider returns credentials .
|
32
|
public static function env ( ) { return function ( ) { $ enabled = getenv ( self :: ENV_ENABLED ) ; if ( $ enabled !== false ) { return Promise \ promise_for ( new Configuration ( $ enabled , getenv ( self :: ENV_PORT ) ? : self :: DEFAULT_PORT , getenv ( self :: ENV_CLIENT_ID ) ? : self :: DEFAULT_CLIENT_ID ) ) ; } return self :: reject ( 'Could not find environment variable CSM config' . ' in ' . self :: ENV_ENABLED . '/' . self :: ENV_PORT . '/' . self :: ENV_CLIENT_ID ) ; } ; }
|
Provider that creates CSM config from environment variables .
|
33
|
public static function fallback ( ) { return function ( ) { return Promise \ promise_for ( new Configuration ( self :: DEFAULT_ENABLED , self :: DEFAULT_PORT , self :: DEFAULT_CLIENT_ID ) ) ; } ; }
|
Fallback config options when other sources are not set .
|
34
|
public static function memoize ( callable $ provider ) { return function ( ) use ( $ provider ) { static $ result ; static $ isConstant ; if ( $ isConstant ) { return $ result ; } if ( null === $ result ) { $ result = $ provider ( ) ; } return $ result -> then ( function ( ConfigurationInterface $ config ) use ( & $ isConstant ) { $ isConstant = true ; return $ config ; } ) ; } ; }
|
Wraps a CSM config provider and caches previously provided configuration .
|
35
|
public function getSignedCookie ( array $ options ) { foreach ( [ 'key_pair_id' , 'private_key' ] as $ required ) { if ( ! isset ( $ options [ $ required ] ) ) { throw new \ InvalidArgumentException ( "$required is required" ) ; } } $ cookieSigner = new CookieSigner ( $ options [ 'key_pair_id' ] , $ options [ 'private_key' ] ) ; return $ cookieSigner -> getSignedCookie ( isset ( $ options [ 'url' ] ) ? $ options [ 'url' ] : null , isset ( $ options [ 'expires' ] ) ? $ options [ 'expires' ] : null , isset ( $ options [ 'policy' ] ) ? $ options [ 'policy' ] : null ) ; }
|
Create a signed Amazon CloudFront cookie .
|
36
|
public function url_stat ( $ path , $ flags ) { $ this -> initProtocol ( $ path ) ; $ split = explode ( '://' , $ path ) ; $ path = strtolower ( $ split [ 0 ] ) . '://' . $ split [ 1 ] ; if ( $ value = $ this -> getCacheStorage ( ) -> get ( $ path ) ) { return $ value ; } $ stat = $ this -> createStat ( $ path , $ flags ) ; if ( is_array ( $ stat ) ) { $ this -> getCacheStorage ( ) -> set ( $ path , $ stat ) ; } return $ stat ; }
|
Provides information for is_dir is_file filesize etc . Works on buckets keys and prefixes .
|
37
|
private function validate ( $ path , $ mode ) { $ errors = [ ] ; if ( ! $ this -> getOption ( 'Key' ) ) { $ errors [ ] = 'Cannot open a bucket. You must specify a path in the ' . 'form of s3://bucket/key' ; } if ( ! in_array ( $ mode , [ 'r' , 'w' , 'a' , 'x' ] ) ) { $ errors [ ] = "Mode not supported: {$mode}. " . "Use one 'r', 'w', 'a', or 'x'." ; } if ( $ mode == 'x' && $ this -> getClient ( ) -> doesObjectExist ( $ this -> getOption ( 'Bucket' ) , $ this -> getOption ( 'Key' ) , $ this -> getOptions ( true ) ) ) { $ errors [ ] = "{$path} already exists on Amazon S3" ; } return $ errors ; }
|
Validates the provided stream arguments for fopen and returns an array of errors .
|
38
|
private function getOptions ( $ removeContextData = false ) { if ( $ this -> context === null ) { $ options = [ ] ; } else { $ options = stream_context_get_options ( $ this -> context ) ; $ options = isset ( $ options [ $ this -> protocol ] ) ? $ options [ $ this -> protocol ] : [ ] ; } $ default = stream_context_get_options ( stream_context_get_default ( ) ) ; $ default = isset ( $ default [ $ this -> protocol ] ) ? $ default [ $ this -> protocol ] : [ ] ; $ result = $ this -> params + $ options + $ default ; if ( $ removeContextData ) { unset ( $ result [ 'client' ] , $ result [ 'seekable' ] , $ result [ 'cache' ] ) ; } return $ result ; }
|
Get the stream context options available to the current stream
|
39
|
private function triggerError ( $ errors , $ flags = null ) { if ( $ flags & STREAM_URL_STAT_QUIET ) { return $ flags & STREAM_URL_STAT_LINK ? $ this -> formatUrlStat ( false ) : false ; } trigger_error ( implode ( "\n" , ( array ) $ errors ) , E_USER_WARNING ) ; return false ; }
|
Trigger one or more errors
|
40
|
private function formatUrlStat ( $ result = null ) { $ stat = $ this -> getStatTemplate ( ) ; switch ( gettype ( $ result ) ) { case 'NULL' : case 'string' : $ stat [ 'mode' ] = $ stat [ 2 ] = 0040777 ; break ; case 'array' : $ stat [ 'mode' ] = $ stat [ 2 ] = 0100777 ; if ( isset ( $ result [ 'ContentLength' ] ) ) { $ stat [ 'size' ] = $ stat [ 7 ] = $ result [ 'ContentLength' ] ; } elseif ( isset ( $ result [ 'Size' ] ) ) { $ stat [ 'size' ] = $ stat [ 7 ] = $ result [ 'Size' ] ; } if ( isset ( $ result [ 'LastModified' ] ) ) { $ stat [ 'mtime' ] = $ stat [ 9 ] = $ stat [ 'ctime' ] = $ stat [ 10 ] = strtotime ( $ result [ 'LastModified' ] ) ; } } return $ stat ; }
|
Prepare a url_stat result array
|
41
|
private function createBucket ( $ path , array $ params ) { if ( $ this -> getClient ( ) -> doesBucketExist ( $ params [ 'Bucket' ] ) ) { return $ this -> triggerError ( "Bucket already exists: {$path}" ) ; } return $ this -> boolCall ( function ( ) use ( $ params , $ path ) { $ this -> getClient ( ) -> createBucket ( $ params ) ; $ this -> clearCacheKey ( $ path ) ; return true ; } ) ; }
|
Creates a bucket for the given parameters .
|
42
|
private function deleteSubfolder ( $ path , $ params ) { $ prefix = rtrim ( $ params [ 'Key' ] , '/' ) . '/' ; $ result = $ this -> getClient ( ) -> listObjects ( [ 'Bucket' => $ params [ 'Bucket' ] , 'Prefix' => $ prefix , 'MaxKeys' => 1 ] ) ; if ( $ contents = $ result [ 'Contents' ] ) { return ( count ( $ contents ) > 1 || $ contents [ 0 ] [ 'Key' ] != $ prefix ) ? $ this -> triggerError ( 'Subfolder is not empty' ) : $ this -> unlink ( rtrim ( $ path , '/' ) . '/' ) ; } return $ result [ 'CommonPrefixes' ] ? $ this -> triggerError ( 'Subfolder contains nested folders' ) : true ; }
|
Deletes a nested subfolder if it is empty .
|
43
|
private function boolCall ( callable $ fn , $ flags = null ) { try { return $ fn ( ) ; } catch ( \ Exception $ e ) { return $ this -> triggerError ( $ e -> getMessage ( ) , $ flags ) ; } }
|
Invokes a callable and triggers an error if an exception occurs while calling the function .
|
44
|
private function getSize ( ) { $ size = $ this -> body -> getSize ( ) ; return $ size !== null ? $ size : $ this -> size ; }
|
Returns the size of the opened object body .
|
45
|
public function getInput ( ) { if ( ! $ this -> input ) { if ( $ input = $ this [ 'input' ] ) { $ this -> input = $ this -> shapeFor ( $ input ) ; } else { $ this -> input = new StructureShape ( [ ] , $ this -> shapeMap ) ; } } return $ this -> input ; }
|
Get the input shape of the operation .
|
46
|
public function getOutput ( ) { if ( ! $ this -> output ) { if ( $ output = $ this [ 'output' ] ) { $ this -> output = $ this -> shapeFor ( $ output ) ; } else { $ this -> output = new StructureShape ( [ ] , $ this -> shapeMap ) ; } } return $ this -> output ; }
|
Get the output shape of the operation .
|
47
|
public function getErrors ( ) { if ( $ this -> errors === null ) { if ( $ errors = $ this [ 'errors' ] ) { foreach ( $ errors as $ key => $ error ) { $ errors [ $ key ] = $ this -> shapeFor ( $ error ) ; } $ this -> errors = $ errors ; } else { $ this -> errors = [ ] ; } } return $ this -> errors ; }
|
Get an array of operation error shapes .
|
48
|
public function start ( CommandInterface $ cmd , RequestInterface $ req ) { $ ticket = uniqid ( ) ; $ this -> entries [ $ ticket ] = [ 'command' => $ cmd , 'request' => $ req , 'result' => null , 'exception' => null , ] ; return $ ticket ; }
|
Initiate an entry being added to the history .
|
49
|
public function registerSessionHandler ( array $ config = [ ] ) { $ handler = SessionHandler :: fromClient ( $ this , $ config ) ; $ handler -> register ( ) ; return $ handler ; }
|
Convenience method for instantiating and registering the DynamoDB Session handler with this DynamoDB client object .
|
50
|
public function createCredentials ( Result $ result ) { if ( ! $ result -> hasKey ( 'Credentials' ) ) { throw new \ InvalidArgumentException ( 'Result contains no credentials' ) ; } $ c = $ result [ 'Credentials' ] ; return new Credentials ( $ c [ 'AccessKeyId' ] , $ c [ 'SecretAccessKey' ] , isset ( $ c [ 'SessionToken' ] ) ? $ c [ 'SessionToken' ] : null , isset ( $ c [ 'Expiration' ] ) && $ c [ 'Expiration' ] instanceof \ DateTimeInterface ? ( int ) $ c [ 'Expiration' ] -> format ( 'U' ) : null ) ; }
|
Creates credentials from the result of an STS operations
|
51
|
private function extractHeader ( $ name , Shape $ shape , ResponseInterface $ response , & $ result ) { $ value = $ response -> getHeaderLine ( $ shape [ 'locationName' ] ? : $ name ) ; switch ( $ shape -> getType ( ) ) { case 'float' : case 'double' : $ value = ( float ) $ value ; break ; case 'long' : $ value = ( int ) $ value ; break ; case 'boolean' : $ value = filter_var ( $ value , FILTER_VALIDATE_BOOLEAN ) ; break ; case 'blob' : $ value = base64_decode ( $ value ) ; break ; case 'timestamp' : try { if ( ! empty ( $ shape [ 'timestampFormat' ] ) && $ shape [ 'timestampFormat' ] === 'unixTimestamp' ) { $ value = DateTimeResult :: fromEpoch ( $ value ) ; } $ value = new DateTimeResult ( $ value ) ; break ; } catch ( \ Exception $ e ) { return ; } case 'string' : if ( $ shape [ 'jsonvalue' ] ) { $ value = $ this -> parseJson ( base64_decode ( $ value ) , $ response ) ; } break ; } $ result [ $ name ] = $ value ; }
|
Extract a single header from the response into the result .
|
52
|
private function extractHeaders ( $ name , Shape $ shape , ResponseInterface $ response , & $ result ) { $ result [ $ name ] = [ ] ; $ prefix = $ shape [ 'locationName' ] ; $ prefixLen = strlen ( $ prefix ) ; foreach ( $ response -> getHeaders ( ) as $ k => $ values ) { if ( ! $ prefixLen ) { $ result [ $ name ] [ $ k ] = implode ( ', ' , $ values ) ; } elseif ( stripos ( $ k , $ prefix ) === 0 ) { $ result [ $ name ] [ substr ( $ k , $ prefixLen ) ] = implode ( ', ' , $ values ) ; } } }
|
Extract a map of headers with an optional prefix from the response .
|
53
|
private function extractStatus ( $ name , ResponseInterface $ response , array & $ result ) { $ result [ $ name ] = ( int ) $ response -> getStatusCode ( ) ; }
|
Places the status code of the response into the result array .
|
54
|
private function getHeaderBlacklist ( ) { return [ 'cache-control' => true , 'content-type' => true , 'content-length' => true , 'expect' => true , 'max-forwards' => true , 'pragma' => true , 'range' => true , 'te' => true , 'if-match' => true , 'if-none-match' => true , 'if-modified-since' => true , 'if-unmodified-since' => true , 'if-range' => true , 'accept' => true , 'authorization' => true , 'proxy-authorization' => true , 'from' => true , 'referer' => true , 'user-agent' => true , 'x-amzn-trace-id' => true , 'aws-sdk-invocation-id' => true , 'aws-sdk-retry' => true , ] ; }
|
The following headers are not signed because signing these headers would potentially cause a signature mismatch when sending a request through a proxy or if modified at the HTTP client level .
|
55
|
private function getPresignHeaders ( array $ headers ) { $ presignHeaders = [ ] ; $ blacklist = $ this -> getHeaderBlacklist ( ) ; foreach ( $ headers as $ name => $ value ) { $ lName = strtolower ( $ name ) ; if ( ! isset ( $ blacklist [ $ lName ] ) && $ name !== self :: AMZ_CONTENT_SHA256_HEADER ) { $ presignHeaders [ ] = $ lName ; } } return $ presignHeaders ; }
|
Get the headers that were used to pre - sign the request . Used for the X - Amz - SignedHeaders header .
|
56
|
public static function convertPostToGet ( RequestInterface $ request ) { if ( $ request -> getMethod ( ) !== 'POST' ) { throw new \ InvalidArgumentException ( 'Expected a POST request but ' . 'received a ' . $ request -> getMethod ( ) . ' request.' ) ; } $ sr = $ request -> withMethod ( 'GET' ) -> withBody ( Psr7 \ stream_for ( '' ) ) -> withoutHeader ( 'Content-Type' ) -> withoutHeader ( 'Content-Length' ) ; if ( $ request -> getHeaderLine ( 'Content-Type' ) === 'application/x-www-form-urlencoded' ) { $ body = ( string ) $ request -> getBody ( ) ; $ sr = $ sr -> withUri ( $ sr -> getUri ( ) -> withQuery ( $ body ) ) ; } return $ sr ; }
|
Converts a POST request to a GET request by moving POST fields into the query string .
|
57
|
public static function env ( $ cacheLimit = self :: DEFAULT_CACHE_LIMIT ) { return function ( ) use ( $ cacheLimit ) { $ enabled = getenv ( self :: ENV_ENABLED ) ; if ( $ enabled === false || $ enabled === '' ) { $ enabled = getenv ( self :: ENV_ENABLED_ALT ) ; } if ( $ enabled !== false && $ enabled !== '' ) { return Promise \ promise_for ( new Configuration ( $ enabled , $ cacheLimit ) ) ; } return self :: reject ( 'Could not find environment variable config' . ' in ' . self :: ENV_ENABLED ) ; } ; }
|
Provider that creates config from environment variables .
|
58
|
public static function ini ( $ profile = null , $ filename = null , $ cacheLimit = self :: DEFAULT_CACHE_LIMIT ) { $ filename = $ filename ? : ( self :: getHomeDir ( ) . '/.aws/config' ) ; $ profile = $ profile ? : ( getenv ( self :: ENV_PROFILE ) ? : 'default' ) ; return function ( ) use ( $ profile , $ filename , $ cacheLimit ) { if ( ! is_readable ( $ filename ) ) { return self :: reject ( "Cannot read configuration from $filename" ) ; } $ data = \ Aws \ parse_ini_file ( $ filename , true ) ; if ( $ data === false ) { return self :: reject ( "Invalid config file: $filename" ) ; } if ( ! isset ( $ data [ $ profile ] ) ) { return self :: reject ( "'$profile' not found in config file" ) ; } if ( ! isset ( $ data [ $ profile ] [ 'endpoint_discovery_enabled' ] ) ) { return self :: reject ( "Required endpoint discovery config values not present in INI profile '{$profile}' ({$filename})" ) ; } return Promise \ promise_for ( new Configuration ( $ data [ $ profile ] [ 'endpoint_discovery_enabled' ] , $ cacheLimit ) ) ; } ; }
|
Config provider that creates config using an ini file stored in the current user s home directory .
|
59
|
public function appendException ( ) { foreach ( func_get_args ( ) as $ value ) { if ( $ value instanceof \ Exception || $ value instanceof \ Throwable ) { $ this -> queue [ ] = $ value ; } else { throw new \ InvalidArgumentException ( 'Expected an \Exception or \Throwable.' ) ; } } }
|
Adds one or more \ Exception or \ Throwable to the queue
|
60
|
public function read ( $ s3BucketName , $ logFileKey ) { $ command = $ this -> s3Client -> getCommand ( 'GetObject' , [ 'Bucket' => ( string ) $ s3BucketName , 'Key' => ( string ) $ logFileKey , 'ResponseContentEncoding' => 'x-gzip' ] ) ; $ command [ '@http' ] [ 'headers' ] [ 'Accept-Encoding' ] = 'gzip' ; $ result = $ this -> s3Client -> execute ( $ command ) ; $ logData = json_decode ( $ result [ 'Body' ] , true ) ; return isset ( $ logData [ 'Records' ] ) ? $ logData [ 'Records' ] : [ ] ; }
|
Downloads unzips and reads a CloudTrail log file from Amazon S3
|
61
|
private function parseError ( array $ err , RequestInterface $ request , CommandInterface $ command , array $ stats ) { if ( ! isset ( $ err [ 'exception' ] ) ) { throw new \ RuntimeException ( 'The HTTP handler was rejected without an "exception" key value pair.' ) ; } $ serviceError = "AWS HTTP error: " . $ err [ 'exception' ] -> getMessage ( ) ; if ( ! isset ( $ err [ 'response' ] ) ) { $ parts = [ 'response' => null ] ; } else { try { $ parts = call_user_func ( $ this -> errorParser , $ err [ 'response' ] ) ; $ serviceError .= " {$parts['code']} ({$parts['type']}): " . "{$parts['message']} - " . $ err [ 'response' ] -> getBody ( ) ; } catch ( ParserException $ e ) { $ parts = [ ] ; $ serviceError .= ' Unable to parse error information from ' . "response - {$e->getMessage()}" ; } $ parts [ 'response' ] = $ err [ 'response' ] ; } $ parts [ 'exception' ] = $ err [ 'exception' ] ; $ parts [ 'request' ] = $ request ; $ parts [ 'connection_error' ] = ! empty ( $ err [ 'connection_error' ] ) ; $ parts [ 'transfer_stats' ] = $ stats ; return new $ this -> exceptionClass ( sprintf ( 'Error executing "%s" on "%s"; %s' , $ command -> getName ( ) , $ request -> getUri ( ) , $ serviceError ) , $ command , $ parts , $ err [ 'exception' ] ) ; }
|
Parses a rejection into an AWS error .
|
62
|
private function buildListObjectsIterator ( array $ options ) { $ startDate = isset ( $ options [ self :: START_DATE ] ) ? $ this -> normalizeDateValue ( $ options [ self :: START_DATE ] ) : null ; $ endDate = isset ( $ options [ self :: END_DATE ] ) ? $ this -> normalizeDateValue ( $ options [ self :: END_DATE ] ) : null ; $ parts = [ 'prefix' => isset ( $ options [ self :: KEY_PREFIX ] ) ? $ options [ self :: KEY_PREFIX ] : null , 'account' => isset ( $ options [ self :: ACCOUNT_ID ] ) ? $ options [ self :: ACCOUNT_ID ] : self :: PREFIX_WILDCARD , 'region' => isset ( $ options [ self :: LOG_REGION ] ) ? $ options [ self :: LOG_REGION ] : self :: PREFIX_WILDCARD , 'date' => $ this -> determineDateForPrefix ( $ startDate , $ endDate ) , ] ; $ candidatePrefix = ltrim ( strtr ( self :: PREFIX_TEMPLATE , $ parts ) , '/' ) ; $ logKeyPrefix = $ candidatePrefix ; $ index = strpos ( $ candidatePrefix , self :: PREFIX_WILDCARD ) ; if ( $ index !== false ) { $ logKeyPrefix = substr ( $ candidatePrefix , 0 , $ index ) ; } $ objectsIterator = $ this -> s3Client -> getIterator ( 'ListObjects' , [ 'Bucket' => $ this -> s3BucketName , 'Prefix' => $ logKeyPrefix , ] ) ; $ objectsIterator = $ this -> applyRegexFilter ( $ objectsIterator , $ logKeyPrefix , $ candidatePrefix ) ; $ objectsIterator = $ this -> applyDateFilter ( $ objectsIterator , $ startDate , $ endDate ) ; return $ objectsIterator ; }
|
Constructs an S3 ListObjects iterator optionally decorated with FilterIterators based on the provided options .
|
63
|
private function normalizeDateValue ( $ date ) { if ( is_string ( $ date ) ) { $ date = strtotime ( $ date ) ; } elseif ( $ date instanceof \ DateTime ) { $ date = $ date -> format ( 'U' ) ; } elseif ( ! is_int ( $ date ) ) { throw new \ InvalidArgumentException ( 'Date values must be a ' . 'string, an int, or a DateTime object.' ) ; } return $ date ; }
|
Normalizes a date value to a unix timestamp
|
64
|
private function determineDateForPrefix ( $ startDate , $ endDate ) { $ dateParts = array_fill_keys ( [ 'Y' , 'm' , 'd' ] , self :: PREFIX_WILDCARD ) ; if ( $ startDate && $ endDate ) { foreach ( $ dateParts as $ key => & $ value ) { $ candidateValue = date ( $ key , $ startDate ) ; if ( $ candidateValue === date ( $ key , $ endDate ) ) { $ value = $ candidateValue ; } else { break ; } } } return join ( '/' , $ dateParts ) ; }
|
Uses the provided date values to determine the date portion of the prefix
|
65
|
private function applyRegexFilter ( $ objectsIterator , $ logKeyPrefix , $ candidatePrefix ) { if ( $ logKeyPrefix !== $ candidatePrefix ) { $ regex = rtrim ( $ candidatePrefix , '/' . self :: PREFIX_WILDCARD ) . '/' ; $ regex = strtr ( $ regex , [ self :: PREFIX_WILDCARD => '[^/]+' ] ) ; if ( $ logKeyPrefix !== $ regex ) { $ objectsIterator = new \ CallbackFilterIterator ( $ objectsIterator , function ( $ object ) use ( $ regex ) { return preg_match ( "#{$regex}#" , $ object [ 'Key' ] ) ; } ) ; } } return $ objectsIterator ; }
|
Applies a regex iterator filter that limits the ListObjects result set based on the provided options .
|
66
|
private function applyDateFilter ( $ objectsIterator , $ startDate , $ endDate ) { if ( $ startDate || $ endDate ) { $ fn = function ( $ object ) use ( $ startDate , $ endDate ) { if ( ! preg_match ( '/[0-9]{8}T[0-9]{4}Z/' , $ object [ 'Key' ] , $ m ) ) { return false ; } $ date = strtotime ( $ m [ 0 ] ) ; return ( ! $ startDate || $ date >= $ startDate ) && ( ! $ endDate || $ date <= $ endDate ) ; } ; $ objectsIterator = new \ CallbackFilterIterator ( $ objectsIterator , $ fn ) ; } return $ objectsIterator ; }
|
Applies an iterator filter to restrict the ListObjects result set to the specified date range .
|
67
|
public function getVersions ( $ service ) { if ( ! isset ( $ this -> manifest ) ) { $ this -> buildVersionsList ( $ service ) ; } if ( ! isset ( $ this -> manifest [ $ service ] [ 'versions' ] ) ) { return [ ] ; } return array_values ( array_unique ( $ this -> manifest [ $ service ] [ 'versions' ] ) ) ; }
|
Retrieves a list of valid versions for the specified service .
|
68
|
private function buildVersionsList ( $ service ) { $ dir = "{$this->modelsDir}/{$service}/" ; if ( ! is_dir ( $ dir ) ) { return ; } $ results = array_diff ( scandir ( $ dir , SCANDIR_SORT_DESCENDING ) , [ '..' , '.' ] ) ; if ( ! $ results ) { $ this -> manifest [ $ service ] = [ 'versions' => [ ] ] ; } else { $ this -> manifest [ $ service ] = [ 'versions' => [ 'latest' => $ results [ 0 ] ] ] ; $ this -> manifest [ $ service ] [ 'versions' ] += array_combine ( $ results , $ results ) ; } }
|
Build the versions list for the specified service by globbing the dir .
|
69
|
private static function calculateMessageAttributesMd5 ( $ message ) { if ( empty ( $ message [ 'MessageAttributes' ] ) || ! is_array ( $ message [ 'MessageAttributes' ] ) ) { return null ; } ksort ( $ message [ 'MessageAttributes' ] ) ; $ attributeValues = "" ; foreach ( $ message [ 'MessageAttributes' ] as $ name => $ details ) { $ attributeValues .= self :: getEncodedStringPiece ( $ name ) ; $ attributeValues .= self :: getEncodedStringPiece ( $ details [ 'DataType' ] ) ; if ( substr ( $ details [ 'DataType' ] , 0 , 6 ) === 'Binary' ) { $ attributeValues .= pack ( 'c' , 0x02 ) ; $ attributeValues .= self :: getEncodedBinaryPiece ( $ details [ 'BinaryValue' ] ) ; } else { $ attributeValues .= pack ( 'c' , 0x01 ) ; $ attributeValues .= self :: getEncodedStringPiece ( $ details [ 'StringValue' ] ) ; } } return md5 ( $ attributeValues ) ; }
|
Calculates the expected md5 hash of message attributes according to the encoding scheme detailed in SQS documentation .
|
70
|
private function validateMd5 ( ) { return static function ( callable $ handler ) { return function ( CommandInterface $ c , RequestInterface $ r = null ) use ( $ handler ) { if ( $ c -> getName ( ) !== 'ReceiveMessage' ) { return $ handler ( $ c , $ r ) ; } return $ handler ( $ c , $ r ) -> then ( function ( $ result ) use ( $ c , $ r ) { foreach ( ( array ) $ result [ 'Messages' ] as $ msg ) { $ bodyMd5 = self :: calculateBodyMd5 ( $ msg ) ; if ( isset ( $ msg [ 'MD5OfBody' ] ) && $ bodyMd5 !== $ msg [ 'MD5OfBody' ] ) { throw new SqsException ( sprintf ( 'MD5 mismatch. Expected %s, found %s' , $ msg [ 'MD5OfBody' ] , $ bodyMd5 ) , $ c , [ 'code' => 'ClientChecksumMismatch' , 'request' => $ r ] ) ; } if ( isset ( $ msg [ 'MD5OfMessageAttributes' ] ) ) { $ messageAttributesMd5 = self :: calculateMessageAttributesMd5 ( $ msg ) ; if ( $ messageAttributesMd5 !== $ msg [ 'MD5OfMessageAttributes' ] ) { throw new SqsException ( sprintf ( 'Attribute MD5 mismatch. Expected %s, found %s' , $ msg [ 'MD5OfMessageAttributes' ] , $ messageAttributesMd5 ? $ messageAttributesMd5 : 'No Attributes' ) , $ c , [ 'code' => 'ClientChecksumMismatch' , 'request' => $ r ] ) ; } } else if ( isset ( $ msg [ 'MessageAttributes' ] ) ) { throw new SqsException ( sprintf ( 'No Attribute MD5 found. Expected %s' , self :: calculateMessageAttributesMd5 ( $ msg ) ) , $ c , [ 'code' => 'ClientChecksumMismatch' , 'request' => $ r ] ) ; } } return $ result ; } ) ; } ; } ; }
|
Validates ReceiveMessage body and message attribute MD5s .
|
71
|
protected function decrypt ( $ cipherText , MaterialsProvider $ provider , MetadataEnvelope $ envelope , array $ cipherOptions = [ ] ) { $ cipherOptions [ 'Iv' ] = base64_decode ( $ envelope [ MetadataEnvelope :: IV_HEADER ] ) ; $ cipherOptions [ 'TagLength' ] = $ envelope [ MetadataEnvelope :: CRYPTO_TAG_LENGTH_HEADER ] / 8 ; $ cek = $ provider -> decryptCek ( base64_decode ( $ envelope [ MetadataEnvelope :: CONTENT_KEY_V2_HEADER ] ) , json_decode ( $ envelope [ MetadataEnvelope :: MATERIALS_DESCRIPTION_HEADER ] , true ) ) ; $ cipherOptions [ 'KeySize' ] = strlen ( $ cek ) * 8 ; $ cipherOptions [ 'Cipher' ] = $ this -> getCipherFromAesName ( $ envelope [ MetadataEnvelope :: CONTENT_CRYPTO_SCHEME_HEADER ] ) ; $ decryptionSteam = $ this -> getDecryptingStream ( $ cipherText , $ cek , $ cipherOptions ) ; unset ( $ cek ) ; return $ decryptionSteam ; }
|
Builds an AesStreamInterface using cipher options loaded from the MetadataEnvelope and MaterialsProvider .
|
72
|
public function marshalJson ( $ json ) { $ data = json_decode ( $ json ) ; if ( ! ( $ data instanceof \ stdClass ) ) { throw new \ InvalidArgumentException ( 'The JSON document must be valid and be an object at its root.' ) ; } return current ( $ this -> marshalValue ( $ data ) ) ; }
|
Marshal a JSON document from a string to a DynamoDB item .
|
73
|
public function marshalValue ( $ value ) { $ type = gettype ( $ value ) ; if ( $ type === 'string' ) { if ( $ value === '' ) { return $ this -> handleInvalid ( 'empty strings are invalid' ) ; } return [ 'S' => $ value ] ; } if ( $ type === 'integer' || $ type === 'double' || $ value instanceof NumberValue ) { return [ 'N' => ( string ) $ value ] ; } if ( $ type === 'boolean' ) { return [ 'BOOL' => $ value ] ; } if ( $ type === 'NULL' ) { return [ 'NULL' => true ] ; } if ( $ value instanceof SetValue ) { if ( count ( $ value ) === 0 ) { return $ this -> handleInvalid ( 'empty sets are invalid' ) ; } $ previousType = null ; $ data = [ ] ; foreach ( $ value as $ v ) { $ marshaled = $ this -> marshalValue ( $ v ) ; $ setType = key ( $ marshaled ) ; if ( ! $ previousType ) { $ previousType = $ setType ; } elseif ( $ setType !== $ previousType ) { return $ this -> handleInvalid ( 'sets must be uniform in type' ) ; } $ data [ ] = current ( $ marshaled ) ; } return [ $ previousType . 'S' => array_values ( array_unique ( $ data ) ) ] ; } $ dbType = 'L' ; if ( $ value instanceof \ stdClass ) { $ type = 'array' ; $ dbType = 'M' ; } if ( $ type === 'array' || $ value instanceof \ Traversable ) { $ data = [ ] ; $ index = 0 ; foreach ( $ value as $ k => $ v ) { if ( $ v = $ this -> marshalValue ( $ v ) ) { $ data [ $ k ] = $ v ; if ( $ dbType === 'L' && ( ! is_int ( $ k ) || $ k != $ index ++ ) ) { $ dbType = 'M' ; } } } return [ $ dbType => $ data ] ; } if ( is_resource ( $ value ) || $ value instanceof StreamInterface ) { $ value = $ this -> binary ( $ value ) ; } if ( $ value instanceof BinaryValue ) { return [ 'B' => ( string ) $ value ] ; } return $ this -> handleInvalid ( 'encountered unexpected value' ) ; }
|
Marshal a native PHP value into a DynamoDB attribute value .
|
74
|
public static function fromListObjects ( AwsClientInterface $ client , array $ listObjectsParams , array $ options = [ ] ) { $ iter = $ client -> getPaginator ( 'ListObjects' , $ listObjectsParams ) ; $ bucket = $ listObjectsParams [ 'Bucket' ] ; $ fn = function ( BatchDelete $ that ) use ( $ iter ) { return $ iter -> each ( function ( $ result ) use ( $ that ) { $ promises = [ ] ; if ( is_array ( $ result [ 'Contents' ] ) ) { foreach ( $ result [ 'Contents' ] as $ object ) { if ( $ promise = $ that -> enqueue ( $ object ) ) { $ promises [ ] = $ promise ; } } } return $ promises ? Promise \ all ( $ promises ) : null ; } ) ; } ; return new self ( $ client , $ bucket , $ fn , $ options ) ; }
|
Creates a BatchDelete object from all of the paginated results of a ListObjects operation . Each result that is returned by the ListObjects operation will be deleted .
|
75
|
private function createPromise ( ) { $ promise = call_user_func ( $ this -> promiseCreator , $ this ) ; $ this -> promiseCreator = null ; $ cleanup = function ( ) { $ this -> before = $ this -> client = $ this -> queue = null ; } ; return $ promise -> then ( function ( ) use ( $ cleanup ) { return Promise \ promise_for ( $ this -> flushQueue ( ) ) -> then ( $ cleanup ) ; } , function ( $ reason ) use ( $ cleanup ) { $ cleanup ( ) ; return Promise \ rejection_for ( $ reason ) ; } ) ; }
|
Returns a promise that will clean up any references when it completes .
|
76
|
public function getSignedCookie ( $ url = null , $ expires = null , $ policy = null ) { if ( $ url ) { $ this -> validateUrl ( $ url ) ; } $ cookieParameters = [ ] ; $ signature = $ this -> signer -> getSignature ( $ url , $ expires , $ policy ) ; foreach ( $ signature as $ key => $ value ) { $ cookieParameters [ "CloudFront-$key" ] = $ value ; } return $ cookieParameters ; }
|
Create a signed Amazon CloudFront Cookie .
|
77
|
private function getExpired ( ) { if ( count ( $ this -> expired ) < 1 ) { return null ; } $ expired = key ( $ this -> expired ) ; $ this -> increment ( $ this -> expired ) ; return $ expired ; }
|
Get an expired endpoint . Returns null if none found .
|
78
|
public function put ( array $ item , $ table = null ) { $ this -> queue [ ] = [ 'table' => $ this -> determineTable ( $ table ) , 'data' => [ 'PutRequest' => [ 'Item' => $ item ] ] , ] ; $ this -> autoFlush ( ) ; return $ this ; }
|
Adds a put item request to the batch .
|
79
|
public function delete ( array $ key , $ table = null ) { $ this -> queue [ ] = [ 'table' => $ this -> determineTable ( $ table ) , 'data' => [ 'DeleteRequest' => [ 'Key' => $ key ] ] , ] ; $ this -> autoFlush ( ) ; return $ this ; }
|
Adds a delete item request to the batch .
|
80
|
public function flush ( $ untilEmpty = true ) { $ keepFlushing = true ; while ( $ this -> queue && $ keepFlushing ) { $ commands = $ this -> prepareCommands ( ) ; $ pool = new CommandPool ( $ this -> client , $ commands , [ 'before' => $ this -> config [ 'before' ] , 'concurrency' => $ this -> config [ 'pool_size' ] , 'fulfilled' => function ( ResultInterface $ result ) { if ( $ result -> hasKey ( 'UnprocessedItems' ) ) { $ this -> retryUnprocessed ( $ result [ 'UnprocessedItems' ] ) ; } } , 'rejected' => function ( $ reason ) { if ( $ reason instanceof AwsException ) { $ code = $ reason -> getAwsErrorCode ( ) ; if ( $ code === 'ProvisionedThroughputExceededException' ) { $ this -> retryUnprocessed ( $ reason -> getCommand ( ) [ 'RequestItems' ] ) ; } elseif ( is_callable ( $ this -> config [ 'error' ] ) ) { $ this -> config [ 'error' ] ( $ reason ) ; } } } ] ) ; $ pool -> promise ( ) -> wait ( ) ; $ keepFlushing = ( bool ) $ untilEmpty ; } return $ this ; }
|
Flushes the batch by combining all the queued put and delete requests into BatchWriteItem commands and executing them . Unprocessed items are automatically re - queued .
|
81
|
private function autoFlush ( ) { if ( $ this -> config [ 'autoflush' ] && count ( $ this -> queue ) >= $ this -> config [ 'threshold' ] ) { $ this -> flush ( false ) ; } }
|
If autoflush is enabled and the threshold is met flush the batch
|
82
|
public function save ( MetadataEnvelope $ envelope , array $ args ) { foreach ( $ envelope as $ header => $ value ) { $ args [ 'Metadata' ] [ $ header ] = $ value ; } return $ args ; }
|
Places the information in the MetadataEnvelope in to the Meatadata for the PutObject request of the encrypted object .
|
83
|
public function load ( array $ args ) { $ envelope = new MetadataEnvelope ( ) ; $ constantValues = MetadataEnvelope :: getConstantValues ( ) ; foreach ( $ constantValues as $ constant ) { if ( ! empty ( $ args [ 'Metadata' ] [ $ constant ] ) ) { $ envelope [ $ constant ] = $ args [ 'Metadata' ] [ $ constant ] ; } } return $ envelope ; }
|
Generates a MetadataEnvelope according to the Metadata headers from the GetObject result .
|
84
|
public function build ( Shape $ shape , array $ args ) { $ xml = new XMLWriter ( ) ; $ xml -> openMemory ( ) ; $ xml -> startDocument ( '1.0' , 'UTF-8' ) ; $ this -> format ( $ shape , $ shape [ 'locationName' ] ? : $ shape [ 'name' ] , $ args , $ xml ) ; $ xml -> endDocument ( ) ; return $ xml -> outputMemory ( ) ; }
|
Builds the XML body based on an array of arguments .
|
85
|
public static function fromClient ( DynamoDbClient $ client , array $ config = [ ] ) { $ config += [ 'locking' => false ] ; if ( $ config [ 'locking' ] ) { $ connection = new LockingSessionConnection ( $ client , $ config ) ; } else { $ connection = new StandardSessionConnection ( $ client , $ config ) ; } return new static ( $ connection ) ; }
|
Creates a new DynamoDB Session Handler .
|
86
|
public function close ( ) { $ id = session_id ( ) ; if ( $ this -> openSessionId !== $ id || ! $ this -> sessionWritten ) { $ result = $ this -> connection -> write ( $ this -> formatId ( $ id ) , '' , false ) ; $ this -> sessionWritten = ( bool ) $ result ; } return $ this -> sessionWritten ; }
|
Close a session from writing .
|
87
|
public function read ( $ id ) { $ this -> openSessionId = $ id ; $ this -> dataRead = '' ; $ item = $ this -> connection -> read ( $ this -> formatId ( $ id ) ) ; if ( isset ( $ item [ 'expires' ] ) && isset ( $ item [ 'data' ] ) ) { $ this -> dataRead = $ item [ 'data' ] ; if ( $ item [ 'expires' ] <= time ( ) ) { $ this -> dataRead = '' ; $ this -> destroy ( $ id ) ; } } return $ this -> dataRead ; }
|
Read a session stored in DynamoDB .
|
88
|
public function write ( $ id , $ data ) { $ changed = $ id !== $ this -> openSessionId || $ data !== $ this -> dataRead ; $ this -> openSessionId = $ id ; $ this -> sessionWritten = $ this -> connection -> write ( $ this -> formatId ( $ id ) , $ data , $ changed ) ; return $ this -> sessionWritten ; }
|
Write a session to DynamoDB .
|
89
|
public function destroy ( $ id ) { $ this -> openSessionId = $ id ; $ this -> sessionWritten = $ this -> connection -> delete ( $ this -> formatId ( $ id ) ) ; return $ this -> sessionWritten ; }
|
Delete a session stored in DynamoDB .
|
90
|
private function isEof ( $ seekable ) { return $ seekable ? $ this -> source -> tell ( ) < $ this -> source -> getSize ( ) : ! $ this -> source -> eof ( ) ; }
|
Checks if the source is at EOF .
|
91
|
private function determineSource ( $ source ) { if ( is_string ( $ source ) ) { $ source = Psr7 \ try_fopen ( $ source , 'r' ) ; } $ stream = Psr7 \ stream_for ( $ source ) ; if ( ! $ stream -> isReadable ( ) ) { throw new IAE ( 'Source stream must be readable.' ) ; } return $ stream ; }
|
Turns the provided source into a stream and stores it .
|
92
|
public function createSynthesizeSpeechPreSignedUrl ( array $ args ) { $ uri = new Uri ( $ this -> getEndpoint ( ) ) ; $ uri = $ uri -> withPath ( '/v1/speech' ) ; $ this -> formatter = $ this -> formatter ? : new JsonBody ( $ this -> getApi ( ) ) ; $ queryArray = json_decode ( $ this -> formatter -> build ( $ this -> getApi ( ) -> getOperation ( 'SynthesizeSpeech' ) -> getInput ( ) , $ args ) , true ) ; $ query = Psr7 \ build_query ( $ queryArray ) ; $ uri = $ uri -> withQuery ( $ query ) ; $ request = new Request ( 'GET' , $ uri ) ; $ request = $ request -> withBody ( Psr7 \ stream_for ( '' ) ) ; $ signer = new SignatureV4 ( 'polly' , $ this -> getRegion ( ) ) ; return ( string ) $ signer -> presign ( $ request , $ this -> getCredentials ( ) -> wait ( ) , '+15 minutes' ) -> getUri ( ) ; }
|
Create a pre - signed URL for Polly operation SynthesizeSpeech
|
93
|
public function update ( ) { $ backup = file ( $ this -> reflection -> getFileName ( ) ) ; list ( $ preamble , $ class ) = $ this -> splitClassFile ( $ backup ) ; $ preamble = $ this -> stripOutExistingDocBlock ( $ preamble ) ; $ preamble .= $ this -> buildUpdatedDocBlock ( ) ; if ( $ this -> writeClassFile ( implode ( PHP_EOL , [ $ preamble , $ class ] ) ) && $ this -> commandLineLint ( $ this -> reflection -> getFileName ( ) ) ) { return true ; } $ this -> writeClassFile ( implode ( '' , $ backup ) ) ; return false ; }
|
Performs update on class file and lints the output . If the output fails linting the change is reverted .
|
94
|
public static function format ( $ value , $ format ) { if ( $ value instanceof \ DateTime ) { $ value = $ value -> getTimestamp ( ) ; } elseif ( is_string ( $ value ) ) { $ value = strtotime ( $ value ) ; } elseif ( ! is_int ( $ value ) ) { throw new \ InvalidArgumentException ( 'Unable to handle the provided' . ' timestamp type: ' . gettype ( $ value ) ) ; } switch ( $ format ) { case 'iso8601' : return gmdate ( 'Y-m-d\TH:i:s\Z' , $ value ) ; case 'rfc822' : return gmdate ( 'D, d M Y H:i:s \G\M\T' , $ value ) ; case 'unixTimestamp' : return $ value ; default : throw new \ UnexpectedValueException ( 'Unknown timestamp format: ' . $ format ) ; } }
|
Formats a timestamp value for a service .
|
95
|
public static function resolve ( callable $ provider , $ version , $ service , $ region ) { $ result = $ provider ( $ version , $ service , $ region ) ; if ( $ result instanceof SignatureInterface ) { return $ result ; } throw new UnresolvedSignatureException ( "Unable to resolve a signature for $version/$service/$region.\n" . "Valid signature versions include v4 and anonymous." ) ; }
|
Resolves and signature provider and ensures a non - null return value .
|
96
|
public static function memoize ( callable $ provider ) { $ cache = [ ] ; return function ( $ version , $ service , $ region ) use ( & $ cache , $ provider ) { $ key = "($version)($service)($region)" ; if ( ! isset ( $ cache [ $ key ] ) ) { $ cache [ $ key ] = $ provider ( $ version , $ service , $ region ) ; } return $ cache [ $ key ] ; } ; }
|
Creates a signature provider that caches previously created signature objects . The computed cache key is the concatenation of the version service and region .
|
97
|
public static function generateSmtpPassword ( CredentialsInterface $ creds ) { static $ version = "\x02" ; static $ algo = 'sha256' ; static $ message = 'SendRawEmail' ; $ signature = hash_hmac ( $ algo , $ message , $ creds -> getSecretKey ( ) , true ) ; return base64_encode ( $ version . $ signature ) ; }
|
Create an SMTP password for a given IAM user s credentials .
|
98
|
public static function batch ( AwsClientInterface $ client , $ commands , array $ config = [ ] ) { $ results = [ ] ; self :: cmpCallback ( $ config , 'fulfilled' , $ results ) ; self :: cmpCallback ( $ config , 'rejected' , $ results ) ; return ( new self ( $ client , $ commands , $ config ) ) -> promise ( ) -> then ( static function ( ) use ( & $ results ) { ksort ( $ results ) ; return $ results ; } ) -> wait ( ) ; }
|
Executes a pool synchronously and aggregates the results of the pool into an indexed array in the same order as the passed in array .
|
99
|
private static function cmpCallback ( array & $ config , $ name , array & $ results ) { if ( ! isset ( $ config [ $ name ] ) ) { $ config [ $ name ] = function ( $ v , $ k ) use ( & $ results ) { $ results [ $ k ] = $ v ; } ; } else { $ currentFn = $ config [ $ name ] ; $ config [ $ name ] = function ( $ v , $ k ) use ( & $ results , $ currentFn ) { $ currentFn ( $ v , $ k ) ; $ results [ $ k ] = $ v ; } ; } }
|
Adds an onFulfilled or onRejected callback that aggregates results into an array . If a callback is already present it is replaced with the composed function .
|
End of preview. Expand
in Data Studio
No dataset card yet
- Downloads last month
- 11