Result:
found more than 419 distributions - search limited to the first 2001 files matching your query
( run in 0.699 )
Connector
view release on metacpan or search on metacpan
lib/Connector/Iterator.pm view on Meta::CPAN
Connector::Iterator
=head1 Description
Helper to perform a I<set> operation over a list of connector endpoints
while handing errors individually for each connector. The return value
is a hashref with the processed target names as key and an empty value
if no errors occured and the exception message if the target failed. You
must set I<skip_on_error> to enable handling of expcetions, otherwise
they just bubble up and terminate execution of the loop.
Consul
view release on metacpan or search on metacpan
lib/Consul.pm view on Meta::CPAN
=item *
C<timeout>
Request timeout. If a request to Consul takes longer that this, the endpoint
method will fail (default: 15).
=item *
C<token>
lib/Consul.pm view on Meta::CPAN
=item *
C<args>
A hashref containing the original arguments passed in to the endpoint method.
=back
The C<callback> function should be called with a C<Consul::Response> object
containing the values returned by the Consul server in response to the request.
lib/Consul.pm view on Meta::CPAN
Consul itself provides a default C<request_cb> that uses L<HTTP::Tiny> to make
calls to the server. If you provide one, you should honour the value of the
C<timeout> argument.
C<request_cb> can be used in conjunction with the C<cb> option to all API method
endpoints to get asynchronous behaviour. It's recommended however that you
don't use this directly, but rather use a module like L<AnyEvent::Consul> to
take care of that for you.
If you just want to use this module to make simple calls to your Consul
cluster, you can ignore this option entirely.
lib/Consul.pm view on Meta::CPAN
=back
=head1 ENDPOINTS
Individual API endpoints are implemented in separate modules. The following
methods will return a context objects for the named API. Alternatively, you can
request an API context directly from the Consul package. In that case,
C<Consul-E<gt>new> is called implicitly.
# these are equivalent
lib/Consul.pm view on Meta::CPAN
System status API. See L<Consul::API::Status>.
=head1 METHOD OPTIONS
All API methods implemented by the endpoints can take a number of arguments.
Most of those are documented in the endpoint documentation. There are however
some that are common to all methods:
=over 4
=item *
lib/Consul.pm view on Meta::CPAN
=back
=head1 BLOCKING QUERIES
Some Consul API endpoints support a feature called a "blocking query". These
endpoints allow long-polling for changes, and support some extra information
about the server state, including the Raft index, in the response headers.
The corresponding endpoint methods, when called in array context, will return a
second value. This is an object with three methods, C<index>, C<last_contact>
and C<known_leader>, corresponding to the similarly-named header fields. You
can use these to set up state watches, CAS writes, and so on.
See the Consul API docs for more information.
Convos
view release on metacpan or search on metacpan
lib/Convos/public/packed/https___platform_twitter_com_widgets_js.js view on Meta::CPAN
!function(){function provide(t,e){e(function(e){modules[t]=e})}function using(){for(var t,e=Array.prototype.slice.call(arguments,0,-1),i=0,n=[],r=arguments[arguments.length-1];t=e[i];i++){if(!modules[t])throw"[TWITTER] Module dependency missing: "+t;...
}function u(t){this.transportMethod="Fallback",this.options=t,this._createChild()}var l,c="__ready__",d=0;o.prototype=new e.Connection,i.aug(o.prototype,{_createChild:function(){this.options.window?this._createWindow():this._createIframe()},_createIf...
}var n={"embed/timeline.css":{"default":"embed/timeline.3fb0c4c981cd3f8f8dfb6b0ab93d6a9e.default.css","2x":"embed/timeline.3fb0c4c981cd3f8f8dfb6b0ab93d6a9e.2x.css",gif:"embed/timeline.3fb0c4c981cd3f8f8dfb6b0ab93d6a9e.gif.css","default.rtl":"embed/tim...
}),x=[])},e.afterLoad(y.fetchAndRender),t(y)})}),provide("dom/textsize",function(t){function e(t,e,i){for(var n,r=[],o=0;n=i[o];o++)r.push(n[0]),r.push(n[1]);return t+e+r.join(":")}function i(t){var e=t||"";return e.replace(/([A-Z])/g,function(t){ret...
Couch-DB
view release on metacpan or search on metacpan
Improvements:
- implemented pagination with $result->nextPage (untested)
- many documentation fixes
- make cross-reference page available.
- add cross-reference table Couch::DB -> endpoint
version 0.001: Wed 29 May 18:19:12 CEST 2024
- initial release, interface complete but mainly untested.
Courriel
view release on metacpan or search on metacpan
azure-pipelines.yml view on Meta::CPAN
resources:
repositories:
- repository: ci-perl-helpers
type: github
name: houseabsolute/ci-perl-helpers
endpoint: houseabsolute
stages:
- template: templates/helpers/build.yml@ci-perl-helpers
parameters:
debug: true
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-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.
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 {
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);
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,
Daioikachan-Client
view release on metacpan or search on metacpan
lib/Daioikachan/Client.pm view on Meta::CPAN
timeout => 10,
defined $args->{ua_options} ? %{$args->{ua_options}} : (),
);
my $default_channel = (defined $args->{default_channel} && ($args->{default_channel} ne '')) ? $args->{default_channel} : '#notify';
my $endpoint = (defined $args->{endpoint} && ($args->{endpoint} ne '')) ? $args->{endpoint} : die 'Undefined endpoint';
my $headers = $args->{headers};
return bless {
ua => $ua,
headers => $headers,
default_channel => $default_channel,
endpoint => $endpoint,
}, $class;
}
sub notice {
my ($self, $args) = @_;
lib/Daioikachan/Client.pm view on Meta::CPAN
my ($self, $args) = @_;
my $channel = (defined $args->{channel} && ($args->{channel} ne '')) ? $args->{channel} : $self->{default_channel};
return $self->{ua}->post(
$self->{endpoint} . $args->{type},
$self->{headers},
{
channel => $channel,
message => $args->{message},
},
lib/Daioikachan/Client.pm view on Meta::CPAN
=head1 SYNOPSIS
use Daioikachan::Client;
my $client = Daioikachan::Client->new({
endpoint => 'http://daioikachan_endpoint.example.com/',
});
# Send message to Daioikachan.
$client->notice({ message => 'foo' });
lib/Daioikachan/Client.pm view on Meta::CPAN
I<$args>:
=over
=item endpoint :Str
Endpoint of Daioikachan server.
You must specify a this parameter.
=item default_channel :Str = #notify
Daje-Generate
view release on metacpan or search on metacpan
lib/Daje/Generate/Perl/CreateSchema.pm view on Meta::CPAN
method build_view_methods($view, $column_names) {
my $methods->{table_name} = $view->{table_name};
$methods->{keys} = $self->_get_keys($column_names);
$methods->{create_endpoint} = 1;
my $method = $self->get_view_list($view->{table_name},$column_names);
push @{$methods->{methods}}, $method ;
return $methods;
}
Daje-Plugin-GenerateSchema
view release on metacpan or search on metacpan
lib/Daje/Plugin/Schema/Create.pm view on Meta::CPAN
sub build_view_methods($self, $view, $column_names) {
my $methods->{table_name} = $view->{table_name};
$methods->{keys} = $self->_get_keys($column_names);
$methods->{create_endpoint} = 1;
my $method = $self->get_view_list($view->{table_name},$column_names);
push @{$methods->{methods}}, $method ;
return $methods;
}
Daje-Workflow-GenerateSchema-Activity
view release on metacpan or search on metacpan
lib/Daje/Workflow/GenerateSchema/Create/Schema.pm view on Meta::CPAN
sub build_view_methods($self, $view, $column_names) {
my $methods->{table_name} = $view->{table_name};
$methods->{keys} = $self->_get_keys($column_names);
$methods->{create_endpoint} = 1;
my $method = $self->get_view_list($view->{table_name},$column_names);
push @{$methods->{methods}}, $method ;
return $methods;
}
( run in 0.699 second using v1.01-cache-2.11-cpan-27979f6cc8f )