view release on metacpan or  search on metacpan

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

    service       => 's3',
  );
}

########################################################################
# Build the endpoint URL for a bucket/key
########################################################################
sub _endpoint {
########################################################################
  my ( $self, $bucket, $key ) = @_;

  my $scheme = $self->{secure} ? 'https' : 'http';
  my $host   = $self->host;

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

    if !defined $bucket || !length $bucket;

  croak 'key is required'
    if !defined $key || !length $key;

  my $url      = $self->_endpoint( $bucket, $key );
  my $response = $self->_request( 'HEAD', $url );

  return undef ## no critic (Subroutines::ProhibitExplicitReturnUndef)
    if _is_not_found($response);

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

    if !defined $bucket || !length $bucket;

  croak 'key is required'
    if !defined $key || !length $key;

  my $url = $self->_endpoint( $bucket, $key );

  my %headers;

  if ( defined $options{range} ) {
    $headers{Range} = $options{range};

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

    if !defined $bucket || !length $bucket;

  croak 'key is required'
    if !defined $key || !length $key;

  my $url = $self->_endpoint( $bucket, $key );

  if ( defined $options{version_id} ) {
    $url .= '?versionId=' . uri_escape_utf8( $options{version_id} );
  }

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

  croak 'bucket is required'
    if !defined $bucket || !length $bucket;

  my $region = $options{region} // $self->region;
  my $url    = $self->_endpoint($bucket);
  my %headers;

  if ( $options{acl} ) {
    $headers{'x-amz-acl'} = $options{acl};
  }

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

  croak 'bucket is required'
    if !defined $bucket || !length $bucket;

  my $region = $options{region} // $self->region;
  my $url    = $self->_endpoint($bucket);

  my $response = $self->_request( 'DELETE', $url, {}, q{}, {}, $region );

  $self->_croak_on_error( $response, 'delete_bucket' );

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

########################################################################
sub list_buckets {
########################################################################
  my ($self) = @_;

  my $url = $self->_endpoint . q{/};  # ensure canonical URI is / not empty

  my $response = $self->_request( 'GET', $url, {}, q{}, {}, 'us-east-1' );

  $self->_croak_on_error( $response, 'list_buckets' );

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

  for my $required (qw( src_bucket src_key dst_bucket dst_key )) {
    croak "$required is required"
      if !defined $args{$required} || !length $args{$required};
  }

  my $url = $self->_endpoint( $args{dst_bucket}, $args{dst_key} );

  # x-amz-copy-source: /src-bucket/encoded-key
  my $copy_source = '/' . $args{src_bucket} . '/' . _encode_key( $args{src_key} );

  my %headers = (

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

    if !defined $key || !length $key;

  croak 'data is required'
    if !defined $data;

  my $url = $self->_endpoint( $bucket, $key );

  my %headers;
  $headers{'Content-Type'} = $options{content_type} // 'application/octet-stream';

  # x-amz-acl header

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

  # Build query string
  my $query = join q{&}, map { uri_escape_utf8($_) . q{=} . uri_escape_utf8( $params{$_} ) }
    sort keys %params;

  my $url = $self->_endpoint($bucket) . q{?} . $query;

  my $response = $self->_request( 'GET', $url );

  return undef ## no critic (Subroutines::ProhibitExplicitReturnUndef)
    if _is_not_found($response);

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

########################################################################
  my ( $self, $bucket, %options ) = @_;

  my $xml = $self->_create_notification_configuration( $bucket, %options );

  my $url = $self->_endpoint($bucket) . q{?notification=};

  my %headers = (
    'Content-Type'   => 'application/xml',
    'Content-Length' => length $xml,
    'Content-MD5'    => encode_base64( md5($xml), q{} ),

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

########################################################################
  my ( $self, $bucket, %options ) = @_;

  my $xml = $self->_create_public_access_block( $bucket, %options );

  my $url = $self->_endpoint($bucket) . q{?publicAccessBlock=};

  my %headers = (
    'Content-Type'   => 'application/xml',
    'Content-Length' => length $xml,
    'Content-MD5'    => encode_base64( md5($xml), q{} ),

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

  my $xml = <<'END_XML';
<NotificationConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/"/>
END_XML

  my $url = $self->_endpoint($bucket) . q{?notification=};

  my %headers = (
    'Content-Type'   => 'application/xml',
    'Content-Length' => length $xml,
    'Content-MD5'    => encode_base64( md5($xml), q{} ),

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

  my ( $self, $bucket ) = @_;

  croak 'bucket is required'
    if !defined $bucket || !length $bucket;

  my $url = $self->_endpoint($bucket) . q{?notification=};

  my $response = $self->_request( 'GET', $url );

  $self->_croak_on_error( $response, 'get_bucket_notification_configuration' );

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

########################################################################
  my ( $self, $bucket, %options ) = @_;

  my $xml = $self->_create_website_configuration( $bucket, %options );

  my $url = $self->_endpoint($bucket) . q{?website=};

  my %headers = (
    'Content-Type'   => 'application/xml',
    'Content-Length' => length $xml,
    'Content-MD5'    => encode_base64( md5($xml), q{} ),

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

  my ( $self, $bucket, %options ) = @_;

  croak 'bucket is required'
    if !defined $bucket || !length $bucket;

  my $url = $self->_endpoint($bucket) . q{?policy=};

  my $response = $self->_request( 'GET', $url );

  return undef ## no critic (Subroutines::ProhibitExplicitReturnUndef)
    if _is_not_found($response);

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

  my ( $self, $bucket ) = @_;

  croak 'bucket is required'
    if !defined $bucket || !length $bucket;

  my $url = $self->_endpoint($bucket) . q{?website=};

  my $response = $self->_request( 'GET', $url );

  return undef ## no critic (Subroutines::ProhibitExplicitReturnUndef)
    if _is_not_found($response);

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

  my ( $self, $bucket ) = @_;

  croak 'bucket is required'
    if !defined $bucket || !length $bucket;

  my $url = $self->_endpoint($bucket) . q{?website=};

  my $response = $self->_request( 'DELETE', $url );

  $self->_croak_on_error( $response, 'delete_bucket_website' );

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

  require JSON::PP;

  my $json = ref $policy ? JSON::PP->new->canonical->encode($policy) : $policy;

  my $url = $self->_endpoint($bucket) . q{?policy=};

  my %headers = (
    'Content-Type'   => 'application/json',
    'Content-Length' => length $json,
    'Content-MD5'    => encode_base64( md5($json), q{} ),

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

WARN) and logs to STDERR.  If Log::Log4perl is not installed, a
minimal internal logger.

=item host

Override the S3 endpoint host. Defaults to C<s3.amazonaws.com>.
Useful for S3-compatible services (MinIO, Ceph, LocalStack).

=item secure

Use HTTPS. Default is 1 (true). Set to 0 only for testing against
local S3-compatible endpoints.

=item timeout

HTTP request timeout in seconds. Default is 30.

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

=item restrict_public_buckets

Each accepts a true/false value. Omitted settings default to true.
Note that hosting content publicly (for example a static website, or
a policy-scoped private bucket that grants anonymous C<GetObject> from
a VPC endpoint) requires the relevant setting to be false so the
bucket policy is not rejected.

=back

=head2 put_bucket_website

  $s3->put_bucket_website($bucket);
  $s3->put_bucket_website($bucket, index => 'index.html', error => 'error.html');

Configures the bucket as an S3 static website endpoint. Returns a true
value on success.

=over 4

=item index

lib/Amazon/S3/Lite.pm  view on Meta::CPAN

=back

=head1 LAMBDA USAGE NOTES

In a Lambda container, credentials come from the execution role via
the ECS credential provider endpoint (indicated by
C<AWS_CONTAINER_CREDENTIALS_RELATIVE_URI> in the environment).
L<Amazon::Credentials> handles this automatically when installed and
is the recommended approach. If you prefer not to take that
dependency, the Lambda runtime also populates C<AWS_ACCESS_KEY_ID>,
C<AWS_SECRET_ACCESS_KEY>, and C<AWS_SESSION_TOKEN> directly, which

 view release on metacpan or  search on metacpan

lib/Amazon/S3.pm  view on Meta::CPAN

    checksum_types
    checksum_algorithm
    credentials
    dns_bucket_names
    digest
    endpoint_url
    err
    errstr
    error
    express
    host

lib/Amazon/S3.pm  view on Meta::CPAN

  $options{express}            //= $FALSE;
  $options{verify_checksums}   //= $TRUE;
  $options{checksum_algorithm} //= 'crc64nvme';
  $options{raise_error}        //= $FALSE;

  croak "ERROR: pass endpoint_url or host but not both\n"
    if $options{endpoint_url} && $options{host};

  if ( my $endpoint_url = $options{endpoint_url} ) {
    @options{qw(secure host)} = _parse_endpoint($endpoint_url);
  }
  elsif ( $options{host} ) {
    if ( $options{host} =~ m{\Ahttps?://}xsm ) {
      warn "host containing a URL is deprecated; use endpoint_url instead\n";

      @options{qw(secure host)} = _parse_endpoint( $options{host} );
    }
    else {
      $options{secure} //= $TRUE;
    }
  }

lib/Amazon/S3.pm  view on Meta::CPAN

  return $self;
}

########################################################################
sub _parse_endpoint {
########################################################################
  my ($endpoint_url) = @_;

  my $uri = URI->new($endpoint_url);

  my $scheme = $uri->scheme;

  croak "ERROR: endpoint_url must include a host\n"
    if !defined $uri->host || !length $uri->host;

  croak "ERROR: endpoint_url must use http or https\n"
    if !defined $scheme || ( $scheme ne 'http' && $scheme ne 'https' );

  croak "ERROR: endpoint_url must not contain a query or fragment\n"
    if defined $uri->query || defined $uri->fragment;

  croak "ERROR: endpoint_url must not contain a path\n"
    if $uri->path && $uri->path ne $SLASH;

  my $secure = $scheme eq 'https' ? $TRUE : $FALSE;
  my $host   = $uri->host_port;

lib/Amazon/S3.pm  view on Meta::CPAN

  if ( $self->_region ) {
    my $host = $self->host;
    $self->get_logger->debug( sub { return 'host: ' . $self->host } );

    # only add region if host was not populated from endpoint_url
    if ( !$self->endpoint_url && $host =~ /\As3[.](.*)?amazonaws/xsm ) {
      $self->host( sprintf 's3.%s.amazonaws.com', $self->_region );
    }
  }

  return $self->_region;

lib/Amazon/S3.pm  view on Meta::CPAN

########################################################################
  my ( $self, $verify_region ) = @_;

  # The "default" region for Amazon is us-east-1
  # This is the region to set it to for listing buckets
  # You may need to reset the signer's endpoint to 'us-east-1'

  # temporarily cache signer
  my $region = $self->_region;
  my $bucket_list;

lib/Amazon/S3.pm  view on Meta::CPAN

  if ($data) {
    $request->content($data);
  }

  $self->signer->region($region);  # always set regional endpoint for signing

  $self->signer->sign($request);

  return $request;
}

lib/Amazon/S3.pm  view on Meta::CPAN

  return $FALSE
    if !is_xml_response($response);

  my $error_hash = $self->_xpc_of_content( $response->content );

  my ( $endpoint, $code, $region, $message )
    = @{$error_hash}{qw(Endpoint Code Region Message)};

  my $condition = eval {
    return 'PermanentRedirect'
      if $code eq 'PermanentRedirect' && $endpoint;

    return 'AuthorizationHeaderMalformed'
      if $code eq 'AuthorizationHeaderMalformed' && $region;

    return 'IllegalLocationConstraintException'

lib/Amazon/S3.pm  view on Meta::CPAN

      # Don't recurse through multiple redirects
      return $FALSE
        if $called_from_redirect;

      # With a permanent redirect error, they are telling us the explicit
      # host to use.  The endpoint will be in the form of bucket.host
      my $host = $endpoint;

      # Remove the bucket name from the front of the host name
      # All the requests will need to be of the form https://host/bucket
      $host =~ s/\A$bucket[.]//xsm;
      $self->host($host);

lib/Amazon/S3.pm  view on Meta::CPAN

      # AuthorizationHeaderMalformed error in order to get the region
      return $self->adjust_region( $bucket, $TRUE );
    },
    AuthorizationHeaderMalformed => sub {
      # Set the signer to use the correct reader evermore
      $self->{signer}->{endpoint} = $region;

      # Only change the host if we haven't been called as a redirect
      # where an exact host has been given
      if ( !$called_from_redirect ) {
        $self->host( sprintf 's3-%s-amazonaws.com', $region );

lib/Amazon/S3.pm  view on Meta::CPAN

      # This is hackish; but in this case the region name only appears in the message
      if ( $message =~ /The (\S+) location/xsm ) {
        my $new_region = $1;

        # Correct the region for the signer
        $self->{signer}->{endpoint} = $new_region;

        # Set the proper host for the region
        $self->host( sprintf 's3.%s.amazonaws.com', $new_region );

        return $TRUE;

lib/Amazon/S3.pm  view on Meta::CPAN

The distribution separates account-level S3 operations from
bucket and object operations.

C<Amazon::S3> represents the S3 client and AWS account context. It
manages credentials, request signing, regions, service endpoints,
bucket creation and discovery, and account-level listing operations.

L<Amazon::S3::Bucket> represents an individual bucket. Object
operations such as uploads, downloads, deletes, ACLs, multipart
uploads, and bucket-scoped listing operations are provided primarily

lib/Amazon/S3.pm  view on Meta::CPAN

C<Amazon::S3> can currently create and list directory buckets.
Object access within directory buckets is not yet supported because
that requires creating an S3 Express session and using the resulting
temporary credentials when signing requests to the directory bucket's
Zonal endpoint.

A directory bucket can be created by supplying an availability zone
to C<add_bucket()>:

  my $bucket = $s3->add_bucket(

lib/Amazon/S3.pm  view on Meta::CPAN

The most recent HTTP request and response can be inspected using
C<last_request()> and C<last_response()>.

These accessors are especially useful when diagnosing signing,
endpoint, header, or protocol problems.

C<raise_error> defaults to false to preserve the historical
C<Amazon::S3> interface. New applications may prefer to enable it when
they want request failures to be impossible to overlook.

lib/Amazon/S3.pm  view on Meta::CPAN

The default is true.

A bucket name that cannot be used as a DNS subdomain is placed in the
request path instead.

=item endpoint_url

Optional explicit S3 service endpoint.

When C<endpoint_url> is supplied, C<Amazon::S3> uses that endpoint as
specified and does not rewrite the host when the configured region
changes.

The C<region> setting still controls the AWS signing region.

This is useful for S3-compatible services, local test environments, and
other cases where the caller must select the service endpoint explicitly.

For example:

  my $s3 = Amazon::S3->new(
    { endpoint_url => 'http://localhost:4566',
      region       => 'us-east-1',
      ...
    }
  );

When C<endpoint_url> is not supplied, C<Amazon::S3> may derive the
standard AWS S3 endpoint from the configured region.

C<endpoint_url> and C<host> may not both be supplied.

=item host

S3 service endpoint.

The default is C<s3.amazonaws.com>.

When C<region()> is set and the host is a standard Amazon S3 endpoint,
C<Amazon::S3> adjusts the host for the configured region.

This option can also be used with S3-compatible and local testing
services.

lib/Amazon/S3.pm  view on Meta::CPAN

=head3 host

  my $host = $s3->host;

  $s3->host($endpoint);

Gets or sets the configured S3 endpoint.

The constructor default is C<s3.amazonaws.com>.

See L</S3-COMPATIBLE SERVICES>.

lib/Amazon/S3.pm  view on Meta::CPAN

C<AWS_DEFAULT_REGION>.

=item 3.

The EC2 instance metadata availability-zone endpoint.

=back

When an availability zone is obtained from instance metadata, the
zone suffix is removed to derive the region.

lib/Amazon/S3.pm  view on Meta::CPAN

region assigned to bucket objects when no bucket-specific region is
supplied.

When the configured host uses the standard C<s3.amazonaws.com> form,
setting the region also adjusts the host to the regional Amazon S3
endpoint.

The constructor default is C<us-east-1>.

=head3 signer

lib/Amazon/S3.pm  view on Meta::CPAN

  );

Lists directory buckets owned by the account.

The optional C<uri_params> hash reference is passed as URI parameters
to the S3 Express control endpoint.

The method temporarily switches the client to the S3 Express control
endpoint for the request and restores the previous express-mode state
afterward.

On success, returns the parsed S3 response.

On failure, returns C<undef> and records error information on the

lib/Amazon/S3.pm  view on Meta::CPAN

information even when authentication values are sanitized.

=head1 S3-COMPATIBLE SERVICES

C<Amazon::S3> can be used with S3-compatible services and local S3
implementations by configuring the service endpoint and related
connection options.

The C<host>, C<secure>, and C<dns_bucket_names> settings are commonly
relevant when using a non-AWS endpoint.

S3-compatible implementations may differ from AWS in supported APIs,
request validation, checksum behavior, or edge cases.

The integration tests used during development include LocalStack, but

lib/Amazon/S3.pm  view on Meta::CPAN

See L</DIRECTORY BUCKETS>.

=head1 TESTING

The distribution includes unit tests and integration tests that
exercise behavior requiring an S3 endpoint.

Run the normal distribution test suite with:

  make test

 view release on metacpan or  search on metacpan

lib/Amazon/SNS/V4.pm  view on Meta::CPAN

	} @{$r->{'ListTopicsResult'}{'Topics'}[0]{'member'}};
}

sub Subscribe
{
	my ($self, $protocol, $topicarn, $endpoint) = @_;

	$self->dispatch({
		'Action'	=> 'Subscribe',
		'Protocol'	=> $protocol,
		'TopicArn'	=> $topicarn,
		'Endpoint'	=> $endpoint,
	});
}

sub Unsubscribe
{

 view release on metacpan or  search on metacpan

lib/Amazon/SNS.pm  view on Meta::CPAN

	} @{$r->{'ListTopicsResult'}{'Topics'}[0]{'member'}};
}

sub Subscribe
{
	my ($self, $protocol, $topicarn, $endpoint) = @_;

	$self->dispatch({
		'Action'	=> 'Subscribe',
		'Protocol'	=> $protocol,
		'TopicArn'	=> $topicarn,
		'Endpoint'	=> $endpoint,
	});
}

sub Unsubscribe
{

 view release on metacpan or  search on metacpan

bin/QueueDaemon.pl  view on Meta::CPAN

    config|c=s
    create-queue|C
    daemonize|d!
    delete-when|D=s
    exit-when|E=s
    endpoint_url|e=s
    help|h
    logfile|L=s
    loglevel|l=s
    max-children|m=i
    max-sleep-time=i

bin/QueueDaemon.pl  view on Meta::CPAN

  autoload $options->{handler};

  my $handler = $options->{handler}->new(
    config             => $config,
    logger             => $logger,
    endpoint_url       => $options->{endpoint_url},
    name               => $options->{queue},
    url                => $options->{'queue-url'},
    message_type       => $options->{'message-type'},
    create_queue       => $options->{'create-queue'},
    wait_time          => $options->{'wait-time'},

bin/QueueDaemon.pl  view on Meta::CPAN

 -C, --create-queue       create the queue if it does not exist
 -d, --daemonize          daemonize the script (default)
     --no-daemonize       
 -D, --delete-when        never, always, error
 -E, --exit-when          never, always, error, false
 -e, --endpoint-url       default: https://sqs.amazonaws.com
 -L, --logfile            name of logfile
 -l, --loglevel           log level (trace, debug, info, warn, error)
 -H, --handler            name of the handler class, default: Amazon::SQS::QueueHandler
 -m, --max-children       not implemented (default: 1)
 -s, --max-sleep-time     default: 5 seconds

 view release on metacpan or  search on metacpan

lib/Amazon/SQS/Simple/AnyEvent.pm  view on Meta::CPAN

  use Amazon::SQS::Simple;
  use Amazon::SQS::Simple::AnyEvent;

  my $sqs = Amazon::SQS::Simple->new($access_key, $secret_key);
  my $queue = $sqs->GetQueue($endpoint);

  my $cb = sub {my $message = shift};

  my $msg   = $queue->ReceiveMessage();     # Blocking
  my $guard = $queue->ReceiveMessage($cb);  # Non-blocking

 view release on metacpan or  search on metacpan

lib/Amazon/SQS/Simple.pm  view on Meta::CPAN

our $VERSION   = '2.07';
our @EXPORT_OK = qw( timestamp );

sub GetQueue {
    my ($self, $queue_endpoint) = @_;

	if ($queue_endpoint =~ /^arn:aws:sqs/) {
		my ($host, $user, $queue);
		(undef, undef, undef, $host, $user, $queue) = split(/:/, $queue_endpoint);
		$queue_endpoint = "https://sqs.$host.amazonaws.com/$user/$queue";
	}

    return Amazon::SQS::Simple::Queue->new(
        $self->{AWSAccessKeyId},	#AWSAccessKeyId and SecretKey are the first two arguments to Amazon::SQS::Simple::Base->new
        $self->{SecretKey},
        %$self,
        Endpoint => $queue_endpoint,
    );
}

sub CreateQueue {
    my ($self, $queue_name, %params) = @_;

lib/Amazon/SQS/Simple.pm  view on Meta::CPAN

=head1 METHODS

=over 2

=item GetQueue($queue_endpoint)

Gets the queue with the given endpoint. Returns a 
C<Amazon::SQS::Simple::Queue> object. (See L<Amazon::SQS::Simple::Queue> for details.)

=item CreateQueue($queue_name, [%opts])

Creates a new queue with the given name. Returns a 

 view release on metacpan or  search on metacpan

lib/Amazon/Signature4/Lite.pm  view on Meta::CPAN

  my ($host, $service, $region) = Amazon::Signature4::Lite->parse_service_url(
    host           => 's3.us-east-2.amazonaws.com',
    default_region => 'us-east-1',
  );

Extracts service name and region from an AWS endpoint URL. Can be
called as a class or instance method.

I<Note: The patterns used for parsing are S3/AWS endpoint focused, not
a general URL parser.>

=head1 DEPENDENCIES

All dependencies are Perl core modules (since 5.10) or already

 view release on metacpan or  search on metacpan

factpacks/jargon-split.fact  view on Meta::CPAN

legal2 is  the trailing linefeed."  Hackers   often model their work as a sort of game played with the   environment in which the objective is to maneuver through the   thicket of `natural laws' to achieve a desired objective.  Their   use of `legal'...
legal3 is  as by   the more conventional one having to do with courts and lawyers.   Compare {language lawyer}, {legalese}. 
legalese is  n. Dense, pedantic verbiage in a language description,   product specification, or interface standard; text that seems   designed to obfuscate and requires a {language lawyer} to   {parse} it.  Though hackers are not afraid of high infor...
legalese2 is  (indeed, they rather enjoy   both), they share a deep and abiding loathing for legalese; they   associate it with deception, {suit}s, and situations in which   hackers generally get the short end of the stick. 
LER is  /L-E-R/ [TMRC, from `Light-Emitting Diode] n. A   light-emitting resistor (that is, one in the process of burning   up).  Ohm's law was broken.  See {SED}.
LERP is  /lerp/ vi.,n. Quasi-acronym for Linear Interpolation, used as a   verb or noun for the operation.  E.g., Bresenham's algorithm lerps   incrementally between the two endpoints of the line.
let the smoke out is  v. To fry hardware (see {fried}).  See   {magic smoke} for the mythology behind this.
letterbomb is  n. A piece of {email} containing {live data}   intended to do nefarious things to the recipient's machine or   terminal.  It is possible, for example, to send letterbombs that   will lock up some specific kinds of terminals when they a...
letterbomb2 is  {cycle power} to unwedge them.   Under UNIX, a letterbomb can also try to get part of its contents   interpreted as a shell command to the mailer.  The results of this   could range from silly to tragic.  See also {Trojan horse};   co...
lexer is  /lek'sr/ n. Common hacker shorthand for `lexical   analyzer', the input-tokenizing stage in the parser for a language   (the part that breaks it into word-like pieces).  "Some C lexers   get confused by the old-style compound ops like `=-'....
lexiphage is  /lek'si-fayj`/ n. A notorious word {chomper} on   ITS.  See {bagbiter}.

factpacks/jargon-split.fact  view on Meta::CPAN

smash the stack3 is  also {aliasing bug},   {fandango on core}, {memory leak}, {precedence lossage},   {overrun screw}. 
smiley is  n. See {emoticon}.
smoke test is  n. 1. A rudimentary form of testing applied to   electronic equipment following repair or reconfiguration, in which   power is applied and the tester checks for sparks, smoke, or other   dramatic signs of fundamental failure.  See {mag...
smoke test2 is  of a piece of software after construction   or a critical change.  See and compare {reality check}.   There is an interesting semi-parallel to this term among   typographers and printers When new typefaces are being punch-cut by   han...
smoke test3 is  smoke, then press   it onto paper) is used to check out new dies. 
smoking clover is  [ITS] n. A {display hack} originally due to   Bill Gosper.  Many convergent lines are drawn on a color monitor in   {AOS} mode (so that every pixel struck has its color   incremented).  The lines all have one endpoint in the middle...
smoking clover2 is  spaced one pixel apart around the   perimeter of a large square.  The color map is then repeatedly   rotated.  This results in a striking, rainbow-hued, shimmering   four-leaf clover.  Gosper joked about keeping it hidden from the...
smoking clover3 is  Administration) lest its   hallucinogenic properties cause it to be banned. 
SMOP is  /S-M-O-P/ [Simple (or Small) Matter of Programming] n.   1. A piece of code, not yet written, whose anticipated length is   significantly greater than its complexity.  Used to refer to a   program that could obviously be written, but is not ...
SMOP2 is  imply that a difficult problem   can be easily solved because a program can be written to do it; the   irony is that it is very clear that writing such a program will be   a great deal of work.  "It's easy to enhance a FORTRAN compiler to  ...
SMOP3 is  Often used   ironically by the intended victim when a suggestion for a program   is made which seems easy to the suggester, but is obviously (to the   victim) a lot of work. 

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

3.05 2011-10-13

    [ENHANCEMENTS]
    - Flavor::Minimum: more minimalistic
    - Flavor::Basic: logout endpoint should be only accept post

3.04 2011-10-11

    [FEATURE ENHACEMENTS]
    * Flavor::Large: better div structure on admin page

 view release on metacpan or  search on metacpan

lib/AnyEvent/Consul.pm  view on Meta::CPAN

AnyEvent::Consul is a thin wrapper around L<Consul> to connect it to
L<AnyEvent::HTTP> for asynchronous operation.

It takes the same arguments and methods as L<Consul> itself, so see the
documentation for that module for details. The important difference is that you
must pass the C<cb> option to the endpoint methods to enable their asynchronous
mode.

There's also a C<on_error> argument. If you pass in a coderef for this
argument, it will be called with a single string arg whenever something goes
wrong internally (usually a HTTP failure). Use it to safely log or cleanup

 view release on metacpan or  search on metacpan

lib/AnyEvent/Discord/Client.pm  view on Meta::CPAN

      },
    );

=item C<api(I<$method>, I<$path>, I<$data>, I<$cb>)>

Invokes the Discord API asynchronously and returns immediately.  C<$method> is the HTTP method to use; C<$path> is the endpoint to call.  If C<$data> is a reference, it is sent as JSON; otherwise, if it is defined, it is sent as a C<x-www-form-urlenc...

=item C<api_sync(I<$method>, I<$path>, I<$data>)>

Invokes the Discord API synchronously and returns the result of the call.  C<$method> is the HTTP method to use; C<$path> is the endpoint to call.  If C<$data> is a reference, it is sent as JSON; otherwise, if it is defined, it is sent as a C<x-www-f...

=item C<websocket_send(I<$op>, I<$d>)>

Sends a raw WebSocket payload as per the L<Discord Gateway|https://discordapp.com/developers/docs/topics/gateway> documentation.

 view release on metacpan or  search on metacpan

lib/AnyEvent/Discord.pm  view on Meta::CPAN

    my $msg = $payload->as_json;
    $self->_trace('ws out: ' . $msg);
    $self->_socket->send($msg);
  }

  # Look up the gateway endpoint using the Discord API
  method _lookup_gateway() {
    my $payload = $self->_discord_api('GET', 'gateway');
    die 'Invalid gateway returned by API' unless ($payload and $payload->{url} and $payload->{url} =~ /^wss/);

    # Add the requested version and encoding to the provided URL

lib/AnyEvent/Discord.pm  view on Meta::CPAN

=item connect()

Start connecting to the Discord API and return immediately. In a new AnyEvent
application, this would come before executing "AnyEvent->condvar->recv". This
method will retrieve the available gateway endpoint, create a connection,
identify itself, begin a heartbeat, and once complete, Discord will fire a
'ready' event to the handler.

=item send($channel_id, $content)

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

0.04  Mon Oct 26 13:59:15 PDT 2009
        - Fixed POD errors
        - Reconnect when a long poll times out with an empty event (kappa)

0.03  Mon Jul 20 11:34:12 PDT 2009
        - Updated API and endpoint to v2. 'method' should now be 'request'.
        - entry data structure has changed and is incompatible.

0.02  Thu Jul 16 20:09:55 PDT 2009
        - Remove debug bits

 view release on metacpan or  search on metacpan

lib/AnyEvent/JSONRPC/HTTP/Client.pm  view on Meta::CPAN

=over 4

=item url => 'Str'

URL to json-RPC endpoint to connect. (Required)

=item username => 'Str'

Username to use for authorization (Optional).

 view release on metacpan or  search on metacpan

lib/AnyEvent/Lingr.pm  view on Meta::CPAN

has 'api_key' => (
    is => 'ro',
);

has 'endpoint' => (
    is      => 'ro',
    default => 'http://lingr.com/api/',
);

has 'session' => (

lib/AnyEvent/Lingr.pm  view on Meta::CPAN

no Mouse;

sub request {
    my ($self, $http_method, $method, $params, $cb) = @_;

    my $uri = URI->new($self->endpoint . $method);
    $uri->query_form($params);

    my $cb_wrap = sub {
        my ($body, $hdr) = @_;

lib/AnyEvent/Lingr.pm  view on Meta::CPAN

    if ($self->_polling_guard) {
        debugf 'polling session is still active, ignoring this request';
        return;
    }

    my $uri = URI->new( $self->endpoint . 'event/observe' );
    $uri->port(8080);
    $uri->query_form({ session => $self->session, counter => $self->counter });

    my $guard = http_get $uri, timeout => 60, sub {
        my ($body, $hdr) = @_;

 view release on metacpan or  search on metacpan

MP.pm  view on Meta::CPAN

=item binds - C<ip:port>

Nodes can only talk to each other by creating some kind of connection to
each other. To do this, nodes should listen on one or more local transport
endpoints - binds.

Currently, only standard C<ip:port> specifications can be used, which
specify TCP ports to listen on. So a bind is basically just a tcp socket
in listening mode that accepts connections from other nodes.

MP.pm  view on Meta::CPAN

Seed nodes are represented by seed IDs.

=item seed IDs - C<host:port>

Seed IDs are transport endpoint(s) (usually a hostname/IP address and a
TCP port) of nodes that should be used as seed nodes.

=item global nodes

An AEMP network needs a discovery service - nodes need to know how to

 view release on metacpan or  search on metacpan

lib/AnyEvent/Mattermost.pm  view on Meta::CPAN

    my $headers = [
        'Content-Type'      => 'application/json',
        'X-Requested-With'  => 'XMLHttpRequest',
    ];

    # initial_load is fine with just the Cookie, other endpoints like channels/
    # require Authorization. We'll just always include both to be sure.
    if (exists $self->{'token'}) {
        push(@{$headers},
            'Cookie'        => 'MMAUTHTOKEN=' . $self->{'token'},
            'Authorization' => 'Bearer ' . $self->{'token'},

 view release on metacpan or  search on metacpan

inc/Test/HTTP/AnyEvent/Server.pm  view on Meta::CPAN

Return URI of a newly created server (with a trailing C</>).

=head2 start_server($prepare_cb)

B<(internal)> Wrapper for the C<tcp_server> from L<AnyEvent::Socket>.
C<$prepare_cb> is used to get the IP address and port of the local socket endpoint and populate respective attributes.

=head1 FUNCTIONS

=head2 _cleanup

 view release on metacpan or  search on metacpan

lib/AnyEvent/ReverseHTTP.pm  view on Meta::CPAN

use base qw(Exporter);
our @EXPORT = qw(reverse_http);

use Any::Moose;

has endpoint => (
    is => 'rw', isa => 'Str',
    required => 1, default => "http://www.reversehttp.net/reversehttp",
);

has label => (

lib/AnyEvent/ReverseHTTP.pm  view on Meta::CPAN

    my $cb = pop;

    my @args =
        @_ == 1 ? qw(label) :
        @_ == 2 ? qw(label token) :
        @_ >= 3 ? qw(endpoint label token) : ();

    my %args; @args{@args} = @_;
    return __PACKAGE__->new(%args, on_request => $cb)->connect;
}

lib/AnyEvent/ReverseHTTP.pm  view on Meta::CPAN

    my %query = (name => $self->label);
    $query{token} = $self->token if $self->token;

    my $body = join "&", map "$_=" . URI::Escape::uri_escape($query{$_}), keys %query;

    http_post $self->endpoint, $body, sub {
        my($body, $hdr) = @_;

        if ($hdr->{Status} eq '201' || $hdr->{Status} eq '204') {
            my $app_url = _extract_link($hdr, 'related');
            $self->on_register->($app_url);

lib/AnyEvent/ReverseHTTP.pm  view on Meta::CPAN

      return "Hello World"; # You can return HTTP::Response object for more control
  };

  # more controls over options and callbacks
  my $server = AnyEvent::ReverseHTTP->new(
      endpoint => "http://www.reversehttp.net/reversehttp",
      label    => "aedemo1234",
      token    => "mytoken",
  );

  $server->on_register(sub {

 view release on metacpan or  search on metacpan

t/02_listen_and_invite-anyevent.t  view on Meta::CPAN

	$uas->listen(
		cb_create      => sub { 
			my ($call,$request,$leg,$from) = @_;
			diag( 'call created' );
			my $response = $request->create_response( '180','Ringing' );
	        $call->{endpoint}->new_response( $call->{ctx},$response,$leg,$from );
			1;
		},
		cb_established => sub { diag( 'call established' ) },
		cb_cleanup     => sub {
			diag( 'call cleaned up' );

 view release on metacpan or  search on metacpan

lib/AnyEvent/SlackBot.pm  view on Meta::CPAN

    type=>'typing',
  };
  $self->send($msg);
}

=item * $self->post_to_web($msg,$endpoint|undef,"FORM"|"JSON"|undef)

Posts the to the given REST Endpoint outside of the WebSocket.

  msg:
    Hash ref representing the requrest being sent
      token: set to $self->token if not set
      scope: set to: 'chat:write:bot' if not set

  endpoint:
    The Rest xxx endpint, the default is 'chat.postMessage'

  type:
    Sets how the data will be sent over
    Supported options are:

lib/AnyEvent/SlackBot.pm  view on Meta::CPAN

      - JSON: converts $msg to a json string and posts

=cut

sub post_to_web {
  my ($self,$msg,$endpoint,$type)=@_;
  $endpoint='chat.postMessage' unless defined($endpoint);
  $type='FORM';

  $self->stats->{running_posts}++;
  my $url="https://slack.com/api/$endpoint";


  $msg->{token}=$self->token unless exists $msg->{token};
  $msg->{scope}='chat:write:bot'  unless exists $msg->{scope};

 view release on metacpan or  search on metacpan

lib/AnyEvent/Twitter/Stream.pm  view on Meta::CPAN

=back

=item B<api_url>

Pass this to override the default URL for the API endpoint.

=item B<request_method>

Pass this to override the default HTTP request method.

 view release on metacpan or  search on metacpan

lib/AnyEvent/Twitter.pm  view on Meta::CPAN

    return bless { %args }, $class;
}

sub get {
    my $cb = pop;
    my ($self, $endpoint, $params) = @_;

    my $type = $endpoint =~ /^http.+\.json$/ ? 'url' : 'api';
    $self->request($type => $endpoint, method => 'GET', params => $params, $cb);

    return $self;
}

sub post {
    my ($self, $endpoint, $params, $cb) = @_;

    my $type = $endpoint =~ /^http.+\.json$/ ? 'url' : 'api';
    $self->request($type => $endpoint, method => 'POST', params => $params, $cb);

    return $self;
}

sub request {

lib/AnyEvent/Twitter.pm  view on Meta::CPAN

        consumer_secret => $consumer_secret,
        callback_url    => 'http://example.com/callback',
        # auth => 'authenticate',
        cb => sub {
            my ($location, $response, $body, $header) = @_;
            # $location is the endpoint where users are asked the permission
            # $response is a hashref of parsed body
            # $body is raw response itself
            # $header is response headers
        },
    );

 view release on metacpan or  search on metacpan

WebDriver.pm  view on Meta::CPAN

         if (exists $res->{error}) {
            $msg = "AyEvent::WebDriver: $res->{error}: $res->{message}";
            $msg .= "\n$res->{stacktrace}caught at" if length $res->{stacktrace};
         } else {
            $msg = "AnyEvent::WebDriver: http status $status (wrong endpoint?), caught";
         }

         Carp::croak $msg;
      }

WebDriver.pm  view on Meta::CPAN

=item new AnyEvent::WebDriver key => value...

Create a new WebDriver object. Example for a remote WebDriver connection
(the only type supported at the moment):

   my $wd = new AnyEvent::WebDriver endpoint => "http://localhost:4444";

Supported keys are:

=over

=item endpoint => $string

For remote connections, the endpoint to connect to (defaults to C<http://localhost:4444>).

=item proxy => $proxyspec

The proxy to use (same as the C<proxy> argument used by
L<AnyEvent::HTTP>). The default is C<undef>, which disables proxies. To

WebDriver.pm  view on Meta::CPAN

sub new {
   my ($class, %kv) = @_;

   bless {
      endpoint   => "http://localhost:4444",
      proxy      => undef,
      persistent => 1,
      autodelete => 1,
      timeout    => 300,
      %kv,

WebDriver.pm  view on Meta::CPAN

=item $sessionstring = $wd->save_session

Save the current session in a string so it can be restored load with
C<load_session>. Note that only the session data itself is stored
(currently the session id and capabilities), not the endpoint information
itself.

The main use of this function is in conjunction with disabled
C<autodelete>, to save a session to e.g., and restore it later. It could
presumably used for other applications, such as using the same session

WebDriver.pm  view on Meta::CPAN

   my ($self, $sid, $caps) = @_;

   $self->{sid}          = $sid;
   $self->{capabilities} = $caps;

   $self->{_ep} = "$self->{endpoint}/session/$self->{sid}/";
}

=back

=head2 SIMPLIFIED API

WebDriver.pm  view on Meta::CPAN

On success, C<< $wd->{sid} >> is set to the session ID, and C<<
$wd->{capabilities} >> is set to the returned capabilities.

Simple example of creating a WebDriver object and a new session:

   my $wd = new AnyEvent::WebDriver endpoint => "http://localhost:4444";
   $wd->new_session ({});

Real-world example with capability negotiation:

   $wd->new_session ({

WebDriver.pm  view on Meta::CPAN

sub new_session_ {
   my ($self, $kv, $cb) = @_;

   $kv->{capabilities} ||= {}; # required by protocol

   local $self->{_ep} = "$self->{endpoint}/";
   $self->post_ (session => $kv, sub {
      my ($status, $res) = @_;

      exists $res->{capabilities}
         or $status = "500"; # blasted chromedriver

WebDriver.pm  view on Meta::CPAN

   my $sid = delete $self->{sid};
   delete $self->{capoabilities};

   return unless defined $sid;

   local $self->{_ep} = "$self->{endpoint}/session/$sid";
   $self->delete_ ("" => $cb);
}

=item $timeouts = $wd->get_timeouts

WebDriver.pm  view on Meta::CPAN

=item $wd->req_ ($method, $uri, $body, $cb->($status, $value))

=item $value = $wd->req ($method, $uri, $body)

Appends the C<$uri> to the C<endpoint/session/{sessionid}/> URL and makes
a HTTP C<$method> request (C<GET>, C<POST> etc.). C<POST> requests can
provide a UTF-8-encoded JSON text as HTTP request body, or the empty
string to indicate no body is used.

For the callback version, the callback gets passed the HTTP status code

 view release on metacpan or  search on metacpan

lib/AnyEvent/XMPP/Writer.pm  view on Meta::CPAN

}

=item B<send_init_stream ($language, $domain, $namespace)>

This method will generate a XMPP stream header. C<$domain> has to be the
domain of the server (or endpoint) we want to connect to.

C<$namespace> is the namespace URI or the tag (from L<AnyEvent::XMPP::Namespaces>)
for the stream namespace. (This is used by L<AnyEvent::XMPP::Component> to connect
as component to a server). C<$namespace> can also be undefined, in this case
the C<client> namespace will be used.

 view release on metacpan or  search on metacpan

lib/AnyEvent/ZeroMQ/Types.pm  view on Meta::CPAN

                $rest =~ /^(?:$interface|$ip);$ip$andport$/;
        return 0;
    }
    return 0;

}, message { 'An endpoint must be in the form "<transport>://<address>"' };

subtype Endpoints, as ArrayRef[Endpoint], message {
    'Each endpoint must be in the form "<transport>://<address>"';
};

sub fixup_endpoint() {
    s{(^[/])/$}{$1}g;
}

coerce Endpoint, from Str, via { fixup_endpoint };

coerce Endpoints, from ArrayRef[Str], via {
    my @array = @$_;
    fixup_endpoint for @array;
    $_ = [@array];
};

my %allowed_sockettype = map { ZeroMQ::Raw::Constants->$_ => $_ } @socket_constants;
subtype SocketType, as Int, where {

 view release on metacpan or  search on metacpan

lib/AnyEvent/Handle.pm  view on Meta::CPAN

read and write queues, EOF status, TLS status and similar properties of
the handle will have been reset.

If, for some reason, the handle is not acceptable, calling C<$retry> will
continue with the next connection target (in case of multi-homed hosts or
SRV records there can be multiple connection endpoints). The C<$retry>
callback can be invoked after the connect callback returns, i.e. one can
start a handshake and then decide to retry with the next host if the
handshake fails.

In most cases, you should ignore the C<$retry> parameter.

 view release on metacpan or  search on metacpan

lib/Apache/SdnFw/js/tinymce/jscripts/tiny_mce/tiny_mce_src.js  view on Meta::CPAN

				// Setup temp range and collapse it
				checkRng = ieRange.duplicate();
				checkRng.collapse(start);

				// Create marker and insert it at the end of the endpoints parent
				marker = dom.create('a');
				parent = checkRng.parentElement();

				// If parent doesn't have any children then set the container to that parent and the index to 0
				if (!parent.hasChildNodes()) {

 view release on metacpan or  search on metacpan

lib/Apache/Session/Browseable/Patroni.pm  view on Meta::CPAN

       DataSource => 'dbi:Pg:dbname=sessions',
       UserName   => $db_user,
       Password   => $db_pass,
       Commit     => 1,

       # List Patroni API endpoints (comma or space separated)
       # Put preferred (local) endpoints first
       PatroniUrl => 'http://1.2.3.4:8008/cluster, http://2.3.4.5:8008/cluster',

       # Optional parameters with defaults:
       # PatroniTimeout             => 3,   # API request timeout in seconds
       # PatroniCacheTTL            => 60,  # Leader cache TTL in seconds

lib/Apache/Session/Browseable/Patroni.pm  view on Meta::CPAN

=back

=head2 SSL/TLS Configuration

By default, SSL certificate verification is B<enabled> when connecting to
HTTPS Patroni endpoints. This protects against man-in-the-middle attacks.

Available SSL options:

=over 4