Result:
found more than 672 distributions - search limited to the first 2001 files matching your query
( run in 1.111 )
Crypt-EAMessage
view release on metacpan or search on metacpan
lib/Crypt/EAMessage.pm view on Meta::CPAN
This will output a random key in hex format suitable for use as an AES256 key.
=head1 SECURITY
Note that this module use L<Storable>. Thus this module should only be used
when the endpoint is trusted. This module will ensure that the stored
object is received without tampering by an intermediary (and is secure even
when an untrusted third party can modify the encrypted message in transit),
because C<thaw> is not called unless the message passes authentication
checks. But if an endpoint can create a malicious message using a valid
key, it is possible that this message could exploit some vulnerability in
the L<Storable> module.
This module does not protect against replay attacks.
Crypt-LE
view release on metacpan or search on metacpan
- Alternative certificates support.
0.36 27 June 2020
- Updates to reflect support for other ACME-compatible CAs/servers.
- Disabling Let's Encrypt specific shortcut when custom servers are used.
- Support for custom ACME servers with custom named directory endpoints.
- Support for custom ACME servers using older specifications.
- Multi-webroot fix.
- Documentation update.
- Dockerfile and examples update.
Crypt-XkcdPassword
view release on metacpan or search on metacpan
lib/Crypt/XkcdPassword/Words/EN/Roget.pm view on Meta::CPAN
endosmotic
endow
endowed
endowment
endpapers
endpoint
ends
endue
endurance
endure
endured
CtrlO-Crypt-XkcdPassword
view release on metacpan or search on metacpan
lib/CtrlO/Crypt/XkcdPassword/Wordlist/eff_large.pm view on Meta::CPAN
endnote
endocrine
endorphin
endorse
endowment
endpoint
endurable
endurance
enduring
energetic
energize
DBD-Chart
view release on metacpan or search on metacpan
dbdchart.html view on Meta::CPAN
<td>
<ol>
<li>:PLOTNUM = <range number of the plot>
<li>:X = <domain value for the datapoint>
<li>:Y = <range value for the datapoint>
<li>:Z = <'top' | 'bottom'> depending on which endpoint of candlestick is focused.
</ol>
</td></tr>
<tr bgcolor=white><td valign=top align=center><b>Box & Whisker</b></td>
<td valign=top>the area of the plotted box, and an<br>
8-pixel diameter circle centered on<br> the lower and upper ends of the whicksers</td>
dbdchart.html view on Meta::CPAN
<td valign=top>arrayref of (xcenter, ycenter, radius) image pixel coordinates of 8-pixel diameter
circle centered on<br>each datapoint, both top and bottom of stick</td>
<td valign=top align=center>range number of the plot</td>
<td valign=top align=center>domain value for the datapoint</td>
<td valign=top align=center>range value for the datapoint</td>
<td valign=top align=center>'top' | 'bottom', depending on which candlestick endpoint is focused.</td></tr>
<tr bgcolor=white><td valign=top align=center><b>Box & Whisker</b></td>
<td valign=top>RECT, CIRCLE</td>
<td valign=top>arrayref of (x,y of upper left of box, x.y of lower right of box) image pixel coordinates of
the box</td>
<td valign=top align=center>range number of the plot</td>
DBD-KingBase
view release on metacpan or search on metacpan
- Fix crash when executing query with two placeholders side by side.
Thanks to Daniel Browning for spotting this. [Greg Sabino Mullane]
- Skip item if no matching key in foreign_key_info.
(CPAN bug #32308) [Greg Sabino Mullane]
- Fix bug in last_insert_id. (CPAN bug #15918) [orentocy@gmail.com]
- Fix pg_description join in table_info(). [Max Cohan max@endpoint.com]
- Make sure arrays handle UTF-8 smoothly (CPAN bug #32479) [Greg Sabino Mullane]
- Force column names to respect utf8-ness. Per report from Ch Lamprect. [Greg Sabino Mullane]
- Make sure array items are marked as UTF as needed.
(CPAN bug #29656) [Greg Sabino Mullane]
- Force SQL_REAL and SQL_NUMERIC to be float8 not float4.
DBD-Patroni
view release on metacpan or search on metacpan
lib/DBD/Patroni.pm view on Meta::CPAN
=over 4
=item patroni_url (required)
Comma-separated list of Patroni REST API endpoints.
=item patroni_lb
Load balancing mode: C<round_robin> (default), C<random>, or C<leader_only>.
DBD-SQLcipher
view release on metacpan or search on metacpan
** is an instance of this class.
*/
struct MemJournal {
sqlite3_io_methods *pMethod; /* Parent class. MUST BE FIRST */
FileChunk *pFirst; /* Head of in-memory chunk-list */
FilePoint endpoint; /* Pointer to the end of the file */
FilePoint readpoint; /* Pointer to the end of the last xRead() */
};
/*
** Read data from the in-memory journal file. This is the implementation
int nRead = iAmt;
int iChunkOffset;
FileChunk *pChunk;
/* SQLite never tries to read past the end of a rollback journal file */
assert( iOfst+iAmt<=p->endpoint.iOffset );
if( p->readpoint.iOffset!=iOfst || iOfst==0 ){
sqlite3_int64 iOff = 0;
for(pChunk=p->pFirst;
ALWAYS(pChunk) && (iOff+JOURNAL_CHUNKSIZE)<=iOfst;
u8 *zWrite = (u8 *)zBuf;
/* An in-memory journal file should only ever be appended to. Random
** access writes are not required by sqlite.
*/
assert( iOfst==p->endpoint.iOffset );
UNUSED_PARAMETER(iOfst);
while( nWrite>0 ){
FileChunk *pChunk = p->endpoint.pChunk;
int iChunkOffset = (int)(p->endpoint.iOffset%JOURNAL_CHUNKSIZE);
int iSpace = MIN(nWrite, JOURNAL_CHUNKSIZE - iChunkOffset);
if( iChunkOffset==0 ){
/* New chunk is required to extend the file. */
FileChunk *pNew = sqlite3_malloc(sizeof(FileChunk));
pChunk->pNext = pNew;
}else{
assert( !p->pFirst );
p->pFirst = pNew;
}
p->endpoint.pChunk = pNew;
}
memcpy(&p->endpoint.pChunk->zChunk[iChunkOffset], zWrite, iSpace);
zWrite += iSpace;
nWrite -= iSpace;
p->endpoint.iOffset += iSpace;
}
return SQLITE_OK;
}
/*
** Query the size of the file in bytes.
*/
static int memjrnlFileSize(sqlite3_file *pJfd, sqlite_int64 *pSize){
MemJournal *p = (MemJournal *)pJfd;
*pSize = (sqlite_int64) p->endpoint.iOffset;
return SQLITE_OK;
}
/*
** Table of methods for MemJournal sqlite3_file object.
DBD-SQLeet
view release on metacpan or search on metacpan
int nChunkSize; /* In-memory chunk-size */
int nSpill; /* Bytes of data before flushing */
int nSize; /* Bytes of data currently in memory */
FileChunk *pFirst; /* Head of in-memory chunk-list */
FilePoint endpoint; /* Pointer to the end of the file */
FilePoint readpoint; /* Pointer to the end of the last xRead() */
int flags; /* xOpen flags */
sqlite3_vfs *pVfs; /* The "real" underlying VFS */
const char *zJournal; /* Name of the journal file */
int iChunkOffset;
FileChunk *pChunk;
#if defined(SQLITE_ENABLE_ATOMIC_WRITE) \
|| defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
if( (iAmt+iOfst)>p->endpoint.iOffset ){
return SQLITE_IOERR_SHORT_READ;
}
#endif
assert( (iAmt+iOfst)<=p->endpoint.iOffset );
assert( p->readpoint.iOffset==0 || p->readpoint.pChunk!=0 );
if( p->readpoint.iOffset!=iOfst || iOfst==0 ){
sqlite3_int64 iOff = 0;
for(pChunk=p->pFirst;
ALWAYS(pChunk) && (iOff+p->nChunkSize)<=iOfst;
if( rc==SQLITE_OK ){
int nChunk = copy.nChunkSize;
i64 iOff = 0;
FileChunk *pIter;
for(pIter=copy.pFirst; pIter; pIter=pIter->pNext){
if( iOff + nChunk > copy.endpoint.iOffset ){
nChunk = copy.endpoint.iOffset - iOff;
}
rc = sqlite3OsWrite(pReal, (u8*)pIter->zChunk, nChunk, iOff);
if( rc ) break;
iOff += nChunk;
}
/* An in-memory journal file should only ever be appended to. Random
** access writes are not required. The only exception to this is when
** the in-memory journal is being used by a connection using the
** atomic-write optimization. In this case the first 28 bytes of the
** journal file may be written as part of committing the transaction. */
assert( iOfst==p->endpoint.iOffset || iOfst==0 );
#if defined(SQLITE_ENABLE_ATOMIC_WRITE) \
|| defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
if( iOfst==0 && p->pFirst ){
assert( p->nChunkSize>iAmt );
memcpy((u8*)p->pFirst->zChunk, zBuf, iAmt);
#else
assert( iOfst>0 || p->pFirst==0 );
#endif
{
while( nWrite>0 ){
FileChunk *pChunk = p->endpoint.pChunk;
int iChunkOffset = (int)(p->endpoint.iOffset%p->nChunkSize);
int iSpace = MIN(nWrite, p->nChunkSize - iChunkOffset);
if( iChunkOffset==0 ){
/* New chunk is required to extend the file. */
FileChunk *pNew = sqlite3_malloc(fileChunkSize(p->nChunkSize));
pChunk->pNext = pNew;
}else{
assert( !p->pFirst );
p->pFirst = pNew;
}
p->endpoint.pChunk = pNew;
}
memcpy((u8*)p->endpoint.pChunk->zChunk + iChunkOffset, zWrite, iSpace);
zWrite += iSpace;
nWrite -= iSpace;
p->endpoint.iOffset += iSpace;
}
p->nSize = iAmt + iOfst;
}
}
static int memjrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){
MemJournal *p = (MemJournal *)pJfd;
if( ALWAYS(size==0) ){
memjrnlFreeChunks(p);
p->nSize = 0;
p->endpoint.pChunk = 0;
p->endpoint.iOffset = 0;
p->readpoint.pChunk = 0;
p->readpoint.iOffset = 0;
}
return SQLITE_OK;
}
/*
** Query the size of the file in bytes.
*/
static int memjrnlFileSize(sqlite3_file *pJfd, sqlite_int64 *pSize){
MemJournal *p = (MemJournal *)pJfd;
*pSize = (sqlite_int64) p->endpoint.iOffset;
return SQLITE_OK;
}
/*
** Table of methods for MemJournal sqlite3_file object.
DBD-SQLite
view release on metacpan or search on metacpan
const sqlite3_io_methods *pMethod; /* Parent class. MUST BE FIRST */
int nChunkSize; /* In-memory chunk-size */
int nSpill; /* Bytes of data before flushing */
FileChunk *pFirst; /* Head of in-memory chunk-list */
FilePoint endpoint; /* Pointer to the end of the file */
FilePoint readpoint; /* Pointer to the end of the last xRead() */
int flags; /* xOpen flags */
sqlite3_vfs *pVfs; /* The "real" underlying VFS */
const char *zJournal; /* Name of the journal file */
u8 *zOut = zBuf;
int nRead = iAmt;
int iChunkOffset;
FileChunk *pChunk;
if( (iAmt+iOfst)>p->endpoint.iOffset ){
return SQLITE_IOERR_SHORT_READ;
}
assert( p->readpoint.iOffset==0 || p->readpoint.pChunk!=0 );
if( p->readpoint.iOffset!=iOfst || iOfst==0 ){
sqlite3_int64 iOff = 0;
if( rc==SQLITE_OK ){
int nChunk = copy.nChunkSize;
i64 iOff = 0;
FileChunk *pIter;
for(pIter=copy.pFirst; pIter; pIter=pIter->pNext){
if( iOff + nChunk > copy.endpoint.iOffset ){
nChunk = copy.endpoint.iOffset - iOff;
}
rc = sqlite3OsWrite(pReal, (u8*)pIter->zChunk, nChunk, iOff);
if( rc ) break;
iOff += nChunk;
}
/* An in-memory journal file should only ever be appended to. Random
** access writes are not required. The only exception to this is when
** the in-memory journal is being used by a connection using the
** atomic-write optimization. In this case the first 28 bytes of the
** journal file may be written as part of committing the transaction. */
assert( iOfst<=p->endpoint.iOffset );
if( iOfst>0 && iOfst!=p->endpoint.iOffset ){
memjrnlTruncate(pJfd, iOfst);
}
if( iOfst==0 && p->pFirst ){
assert( p->nChunkSize>iAmt );
memcpy((u8*)p->pFirst->zChunk, zBuf, iAmt);
}else{
while( nWrite>0 ){
FileChunk *pChunk = p->endpoint.pChunk;
int iChunkOffset = (int)(p->endpoint.iOffset%p->nChunkSize);
int iSpace = MIN(nWrite, p->nChunkSize - iChunkOffset);
assert( pChunk!=0 || iChunkOffset==0 );
if( iChunkOffset==0 ){
/* New chunk is required to extend the file. */
pChunk->pNext = pNew;
}else{
assert( !p->pFirst );
p->pFirst = pNew;
}
pChunk = p->endpoint.pChunk = pNew;
}
assert( pChunk!=0 );
memcpy((u8*)pChunk->zChunk + iChunkOffset, zWrite, iSpace);
zWrite += iSpace;
nWrite -= iSpace;
p->endpoint.iOffset += iSpace;
}
}
}
return SQLITE_OK;
/*
** Truncate the in-memory file.
*/
static int memjrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){
MemJournal *p = (MemJournal *)pJfd;
assert( p->endpoint.pChunk==0 || p->endpoint.pChunk->pNext==0 );
if( size<p->endpoint.iOffset ){
FileChunk *pIter = 0;
if( size==0 ){
memjrnlFreeChunks(p->pFirst);
p->pFirst = 0;
}else{
memjrnlFreeChunks(pIter->pNext);
pIter->pNext = 0;
}
}
p->endpoint.pChunk = pIter;
p->endpoint.iOffset = size;
p->readpoint.pChunk = 0;
p->readpoint.iOffset = 0;
}
return SQLITE_OK;
}
/*
** Query the size of the file in bytes.
*/
static int memjrnlFileSize(sqlite3_file *pJfd, sqlite_int64 *pSize){
MemJournal *p = (MemJournal *)pJfd;
*pSize = (sqlite_int64) p->endpoint.iOffset;
return SQLITE_OK;
}
/*
** Table of methods for MemJournal sqlite3_file object.
DBD-libsql
view release on metacpan or search on metacpan
xt/01_integration.t view on Meta::CPAN
plan tests => 4;
my $ua = LWP::UserAgent->new(timeout => 10);
my $json = JSON->new->utf8;
# Test health endpoint
my $health_response = $ua->get('http://127.0.0.1:8080/health');
ok($health_response->is_success, 'Health endpoint accessible');
# Test Hrana pipeline endpoint
my $request = HTTP::Request->new('POST', 'http://127.0.0.1:8080/v2/pipeline');
$request->header('Content-Type' => 'application/json');
my $pipeline_data = {
requests => [
DBGp-Client
view release on metacpan or search on metacpan
lib/DBGp/Client/Listener.pm view on Meta::CPAN
=head2 listen
$listener->listen;
Starts listening on the endpoint specified to the constructor;
C<die()>s if there is an error.
=cut
sub listen {
DBIO-GraphQL
view release on metacpan or search on metacpan
docs/adr/0005-stateless-base64-pk-cursors.md view on Meta::CPAN
## Rationale
A stateless PK cursor needs no server-side session, no storage, and no
cleanup — every request carries everything required to resume, which is the
right fit for a stateless GraphQL endpoint and for a layer that wants to add
no runtime dependency. Encoding the PK (rather than an offset) makes
`after` a keyset seek (`pk > value`) instead of a large `OFFSET`, so deep
pages stay cheap and do not skew when rows are inserted/deleted between
requests. Base64 keeps the token opaque to clients and URL/transport-safe;
the percent-escaping of `:` and `%` keeps composite-PK decoding unambiguous.
DBIO-MySQL
view release on metacpan or search on metacpan
xbin/dbio-mysql-k8s view on Meta::CPAN
my $deadline = time + 300;
my $last_phase = '';
while (time < $deadline) {
my $pod = eval { $k8s->get('Pod', name => $name, namespace => $ns) };
if ($pod) {
return _get_service_endpoint($k8s, $ns, $name) if _pod_ready($pod);
my $phase = eval { $pod->status->phase } // '?';
# Show phase changes and any waiting reason (e.g. ErrImagePull)
my $reason = eval {
my $cs = $pod->status->containerStatuses // [];
@$cs ? ($cs->[0]->state->waiting // {})->{reason} // '' : ''
xbin/dbio-mysql-k8s view on Meta::CPAN
my ($pod) = @_;
my $conditions = $pod->status->conditions // [];
return grep { $_->type eq 'Ready' && $_->status eq 'True' } @$conditions;
}
sub _get_service_endpoint {
my ($k8s, $ns, $name) = @_;
my $svc = $k8s->get('Service', name => $name, namespace => $ns);
my $node_port = $svc->spec->ports->[0]->nodePort
or die "No nodePort assigned to service $name\n";
DBIO-PostgreSQL-Age
view release on metacpan or search on metacpan
share/skills/dbio-postgresql-age/SKILL.md view on Meta::CPAN
Always parameterise user input — never interpolate.
## Edges
Match endpoints first, then create. Can combine create + create in one query.
```perl
$storage->cypher(
'social',
q{
DBIO-PostgreSQL
view release on metacpan or search on metacpan
xbin/dbio-pg-k8s view on Meta::CPAN
my $deadline = time + 120;
while (time < $deadline) {
my $pod = eval { $k8s->get('Pod', name => $name, namespace => $ns) };
if ($pod && _pod_ready($pod)) {
print STDERR " ready\n";
return _get_service_endpoint($k8s, $ns, $name);
}
print STDERR '.';
Time::HiRes::sleep(3);
}
die "\nTimed out waiting for pod $name\n";
xbin/dbio-pg-k8s view on Meta::CPAN
my ($pod) = @_;
my $conditions = $pod->status->conditions // [];
return grep { $_->type eq 'Ready' && $_->status eq 'True' } @$conditions;
}
sub _get_service_endpoint {
my ($k8s, $ns, $name) = @_;
my $svc = $k8s->get('Service', name => $name, namespace => $ns);
my $node_port = $svc->spec->ports->[0]->nodePort
or die "No nodePort assigned to service $name\n";
DBIO-SQLite
view release on metacpan or search on metacpan
t/90join_torture.t view on Meta::CPAN
);
ok (defined $rs->count);
});
# make sure multiplying endpoints do not lose heir join-path
lives_ok (sub {
my $rs = $schema->resultset('CD')->search (
{ },
{ join => { artwork => 'images' } },
)->get_column('cdid');
DBIO
view release on metacpan or search on metacpan
lib/DBIO/AccessBroker.pm view on Meta::CPAN
my $info = $broker->current_connect_info_for_storage($schema->storage);
# Vault — rotating credentials from OpenBao/Vault
use DBIO::AccessBroker::Vault;
my $broker = DBIO::AccessBroker::Vault->new(
vault => WWW::OpenBao->new(endpoint => 'http://vault:8200', token => $token),
dsn => 'dbi:Pg:dbname=myapp;host=db',
cred_path => 'database/creds/myapp',
ttl => 3600, # credentials valid for 1 hour
refresh_margin => 900, # refresh 15 min before expiry
);
DBIx-BatchChunker
view release on metacpan or search on metacpan
lib/DBIx/BatchChunker.pm view on Meta::CPAN
return 1;
}
#pod =head2 _process_past_max_checker
#pod
#pod Checks to make sure the current endpoint is actually the end, by checking the database.
#pod Its return value determines whether the block should be processed or not.
#pod
#pod See L</process_past_max>.
#pod
#pod =cut
lib/DBIx/BatchChunker.pm view on Meta::CPAN
# At the end: Just process it
$ls->prev_check('at max_id');
return 1;
}
elsif ($chunk_percent < $self->min_chunk_percent) {
# Too few rows: Keep the start ID and accelerate towards a better endpoint
$self->_print_chunk_status('expanded');
$ls->_mark_chunk_timer;
$ls->_increase_multiplier;
$ls->prev_check('too few rows');
return 0;
lib/DBIx/BatchChunker.pm view on Meta::CPAN
Runs the DB work and passes it to the coderef. Its return value determines whether the
block should be processed or not.
=head2 _process_past_max_checker
Checks to make sure the current endpoint is actually the end, by checking the database.
Its return value determines whether the block should be processed or not.
See L</process_past_max>.
=head2 _chunk_count_checker
DBIx-Class
view release on metacpan or search on metacpan
t/90join_torture.t view on Meta::CPAN
);
ok (defined $rs->count);
});
# make sure multiplying endpoints do not lose heir join-path
lives_ok (sub {
my $rs = $schema->resultset('CD')->search (
{ },
{ join => { artwork => 'images' } },
)->get_column('cdid');
DBIx-Custom
view release on metacpan or search on metacpan
t/common-sqlserver.t view on Meta::CPAN
|column_type_usages
|column_xml_schema_collection_usages
|columns
|computed_columns
|configurations
|conversation_endpoints
|conversation_groups
|conversation_priorities
|credentials
|crypt_properties
|cryptographic_providers
|data_spaces
|database_audit_specification_details
|database_audit_specifications
|database_files
|database_mirroring
|database_mirroring_endpoints
|database_permissions
|database_principal_aliases
|database_principals
|database_recovery_status
|database_role_members
t/common-sqlserver.t view on Meta::CPAN
|dm_xe_session_event_actions
|dm_xe_session_events
|dm_xe_session_object_columns
|dm_xe_session_targets
|dm_xe_sessions
|endpoint_webmethods
|endpoints
|event_notification_event_types
|event_notifications
|events
|extended_procedures
|extended_properties
t/common-sqlserver.t view on Meta::CPAN
|fulltext_languages
|fulltext_stoplists
|fulltext_stopwords
|fulltext_system_stopwords
|function_order_columns
|http_endpoints
|identity_columns
|index_columns
|indexes
|internal_tables
|key_constraints
t/common-sqlserver.t view on Meta::CPAN
|server_role_members
|server_sql_modules
|server_trigger_events
|server_triggers
|servers
|service_broker_endpoints
|service_contract_message_usages
|service_contract_usages
|service_contracts
|service_message_types
|service_queue_usages
|service_queues
|services
|soap_endpoints
|spatial_index_tessellations
|spatial_indexes
|spatial_reference_systems
|sql_dependencies
|sql_logins
t/common-sqlserver.t view on Meta::CPAN
|system_views
|systypes
|sysusers
|table_types
|tables
|tcp_endpoints
|trace_categories
|trace_columns
|trace_event_bindings
|trace_events
|trace_subclass_values
t/common-sqlserver.t view on Meta::CPAN
|trigger_events
|triggers
|type_assembly_usages
|types
|user_token
|via_endpoints
|views
|xml_indexes
|xml_schema_attributes
|xml_schema_collections
|xml_schema_component_placements
DBIx-Safe
view release on metacpan or search on metacpan
# -*-cperl-*-
#
# Copyright 2006-2007 Greg Sabino Mullane <greg@endpoint.com>
#
# DBIx::Safe is a safer way of handling database connections.
# You can specify exactly which commands can be run.
#
Bugs should be reported to the author or bucardo-general@bucardo.org.
=head1 AUTHOR
Greg Sabino Mullane <greg@endpoint.com>
=head1 LICENSE AND COPYRIGHT
Copyright 2006-2007 Greg Sabino Mullane <greg@endpoint.com>.
This software is free to use: see the LICENSE file for details.
=cut
DDG
view release on metacpan or search on metacpan
lib/DDG/Rewrite.pm view on Meta::CPAN
# https://github.com/agentzh/echo-nginx-module/issues/30
$cfg .= "\tproxy_set_header Accept-Encoding '';\n";
}
if($uses_echo_module || $content_type_javascript) {
# This is a workaround that deals with endpoints that don't support callback functions.
# So endpoints that don't support callback functions return a content-type of 'application/json'
# because what they're returning is not meant to be executed in the first place.
# Setting content-type to application/javascript for those endpoints solves blocking due to
# mime type mismatches.
$cfg .= "\tmore_set_headers 'Content-Type: application/javascript; charset=utf-8';\n";
}
$cfg .= "\techo_before_body '$callback(';\n" if $wrap_jsonp_callback;
lib/DDG/Rewrite.pm view on Meta::CPAN
$cfg .= "\tproxy_ssl_server_name on;\n" if $scheme =~ /https/;
if($self->has_proxy_cache_valid) {
# This tells Nginx how long the response should be kept.
$cfg .= "\tproxy_cache_valid " . $self->proxy_cache_valid . ";\n";
# Some response headers from the endpoint can affect `proxy_cache_valid` so we ignore them.
# http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_ignore_headers
$cfg .= "\tproxy_ignore_headers X-Accel-Expires Expires Cache-Control Set-Cookie;\n";
}
$cfg .= "\tproxy_ssl_session_reuse ".$self->proxy_ssl_session_reuse.";\n" if $self->has_proxy_ssl_session_reuse;
$cfg .= "\techo_after_body ');';\n" if $wrap_jsonp_callback;
$cfg .= "\techo_after_body '\");';\n" if $wrap_string_callback;
# proxy_intercept_errors is used to handle endpoints that don't return 200 OK
# When we get errors from the endpoint, instead of replying a blank page, it should reply the function instead with no parameters,
# e.g., ddg_spice_dictionary_definition();. The benefit of doing that is that we know for sure that the Spice failed, and we can do
# something about it (we know that the Spice failed because it should return Spice.failed('...') when the parameters are not valid).
if($callback) {
$cfg .= "\tproxy_intercept_errors on;\n";
if ($self->error_fallback) {
DJabberd-Plugin-Balancer
view release on metacpan or search on metacpan
lib/DJabberd/Plugin/Balancer.pm view on Meta::CPAN
several clients.
Every time a client binds to a resource, this plugin will record that
trial and return a different resource, including a sufix in the #999
format. The original JID will be saved as a load balancing
endpoint. Other clients then can try to bind to the same resource, and
will also be assigned different JIDs, but all that will be recorded.
If some client, on the other hand, tries to bind to the resource of
another real client (already with the #999 sufix), the bind will be
denied.
When a message arrives for the load-balancing-endpoint JID, it will be
dispatched randomly through all the clients that tried to bind to that
resource.
Messages to the real JIDs will be delivered normally, iq stanzas will
work as expected, since when sending that, the client will send using
DJabberd
view release on metacpan or search on metacpan
lib/DJabberd/Connection/ComponentOut.pm view on Meta::CPAN
);
sub new {
my ($class, %opts) = @_;
my $endpoint = delete($opts{endpoint}) or $logger->logdie("No endpoint specified");
my $vhost = delete($opts{vhost}) or $logger->logdie("No vhost specified");
my $secret = delete($opts{secret}) || ""; # FIXME: The secret can't currently be the number 0 :)
$logger->logdie("Invalid options ".join(',',keys %opts)) if %opts;
$logger->warning("No shared secret specified for component connection in $vhost") unless $secret;
my $server = $vhost->server;
$logger->debug("Making a $class connecting to ".$endpoint->addr.":".$endpoint->port);
my $sock;
socket $sock, PF_INET, SOCK_STREAM, IPPROTO_TCP;
unless ($sock && defined fileno($sock)) {
$logger->logdie("Failed to allocate socket");
return;
}
IO::Handle::blocking($sock, 0) or $logger->logdie("Failed to make socket non-blocking");
connect $sock, Socket::sockaddr_in($endpoint->port, Socket::inet_aton($endpoint->addr));
my $self = $class->SUPER::new($sock, $server);
$self->watch_write(1);
$self->set_vhost($vhost);
DNS-Hetzner
view release on metacpan or search on metacpan
lib/DNS/Hetzner/API/PrimaryServers.pm view on Meta::CPAN
with 'MooX::Singleton';
use DNS::Hetzner::Schema;
has endpoint => ( is => 'ro', isa => Str, default => sub { 'primary_servers' } );
sub list ($self, %params) {
return $self->_do( 'GetPrimaryServers', \%params, '', { type => 'get' } );
}
lib/DNS/Hetzner/API/PrimaryServers.pm view on Meta::CPAN
=head1 ATTRIBUTES
=over 4
=item * endpoint
=back
=head1 METHODS
DNS-NIOS
view release on metacpan or search on metacpan
lib/DNS/NIOS.pm view on Meta::CPAN
Perl bindings for L<https://www.infoblox.com/company/why-infoblox/nios-platform/>
=head2 Normal usage
Normally, you will add some traits to the client, primarily L<DNS::NIOS::Traits::ApiMethods>
since it provides methods for some endpoints.
=head2 Minimal usage
Without any traits, DNS::NIOS provides access to all API endpoints using the methods described below.
=head1 CONSTRUCTOR
=for Pod::Coverage BUILD
DNS-PunyDNS
view release on metacpan or search on metacpan
lib/DNS/PunyDNS.pm view on Meta::CPAN
}
return \@domains;
}
sub _build_request {
my ( $self, $endpoint, $args ) = @_;
$args->{'ESBUsername'} = $self->{'username'};
$args->{'ESBPassword'} = $self->{'password'};
$args->{'lang'} = 'en';
my @keys = keys %{$args};
my $url = $BASE_URL . $endpoint . '?' . join( '&', map { $_ . '=' . $args->{$_} } @keys );
return $url;
}
sub _get_it {
my ( $self, $endpoint, $args ) = @_;
my $url = $self->_build_request( $endpoint, $args );
delete $self->{'error'};
my $ua = new LWP::UserAgent();
my $req = new HTTP::Request( 'GET', $url );
my $response = $ua->request($req);
DNS-Robot
view release on metacpan or search on metacpan
lib/DNS/Robot.pm view on Meta::CPAN
}
# ── Internal helpers ──
sub _post {
my ($self, $endpoint, $payload) = @_;
my $url = "$self->{base_url}/$endpoint";
my $body = encode_json($payload);
my $res = $self->{http}->request('POST', $url, {
headers => { 'Content-Type' => 'application/json' },
content => $body,
});
croak "DNS::Robot: HTTP $res->{status} from $endpoint"
unless $res->{success};
return decode_json($res->{content});
}
sub _get {
my ($self, $endpoint, $params) = @_;
my $query = join '&', map { "$_=" . _uri_encode($params->{$_}) } sort keys %$params;
my $url = "$self->{base_url}/$endpoint?$query";
my $res = $self->{http}->request('GET', $url);
croak "DNS::Robot: HTTP $res->{status} from $endpoint"
unless $res->{success};
return decode_json($res->{content});
}
sub _uri_encode {
DOCSIS-ConfigFile
view release on metacpan or search on metacpan
lib/DOCSIS/ConfigFile/mibs/PKTC-EVENT-MIB view on Meta::CPAN
pktcDevEvEndpointName OBJECT-TYPE
SYNTAX DisplayString
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"This is the endpoint identifier followed by the FQDN/IP Address
of the device. This is in the form - AALN/X:FQDN/IP Address.
If the event is not specific to an endpoint, then the contents
is just the FQDN/IP address."
::= { pktcDevEventEntry 8 }
--
-- Event Data for Traps - Informs
lib/DOCSIS/ConfigFile/mibs/PKTC-EVENT-MIB view on Meta::CPAN
pktcDevEvReportEndpointName OBJECT-TYPE
SYNTAX DisplayString
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"This is the endpoint identifier followed by the FQDN/IP Address of the
device. in the case of the , this is in the form - AALN/X:FQDN/IP
Address. If the event is not specific to an endpoint, then the contents
is just the FQDN/IP address"
::= { pktcDevEventNotify 8 }
pktcDevEvInform NOTIFICATION-TYPE
OBJECTS { pktcDevEvReportIndex, pktcDevEvReportTime,pktcDevEvReportLevel,
( run in 1.111 second using v1.01-cache-2.11-cpan-870870ed90f )