view release on metacpan or search on metacpan
lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN
The script expects the last line to contain the password in plaintext.
=item B<noop>
Prevents any communication to the cluster from making changes to the settings or data contained therein.
In short, it prevents anything but HEAD and GET requests, B<except> POST requests to the _search endpoint.
=item B<timeout>
Timeout for connections and requests, defaults to 10.
view release on metacpan or search on metacpan
lib/App/Filite/Client.pm view on Meta::CPAN
my $mode = $self->_guess_mode( $file, $opts );
my $method = "share_$mode";
return $self->$method( $file, $opts );
}
sub _get_endpoint {
my ( $self, $mode ) = ( shift, @_ );
my $server = $self->server;
$server = "http://$server" unless $server =~ m{https?:}i;
$server .= '/' unless $server =~ m{/$};
return sprintf( '%s%s', $server, lc( substr( $mode, 0, 1 ) ) );
lib/App/Filite/Client.pm view on Meta::CPAN
my $pt = path( $file );
$filename = $pt->basename;
$content = $pt->slurp;
}
my $endpoint = $self->_get_endpoint( 'file' );
my $response = $self->useragent->post_multipart(
$endpoint => {
file => {
filename => $filename,
content => $content,
content_type => 'application/octet-stream',
},
},
);
return sprintf( '%s/%s', $endpoint, $self->_handle_response( $response ) );
}
sub share_text {
my ( $self, $file, $opts ) = ( shift, @_ );
$opts //= {};
lib/App/Filite/Client.pm view on Meta::CPAN
my $json = encode_json( {
contents => $content,
highlight => $opts->{highlight} ? \1 : \0,
} );
my $endpoint = $self->_get_endpoint( 'text' );
my $response = $self->useragent->post(
$endpoint => {
content => $json,
headers => { 'Content-Type' => 'application/json' },
},
);
return sprintf( '%s/%s', $endpoint, $self->_handle_response( $response ) );
}
sub share_link {
my ( $self, $file, $opts ) = ( shift, @_ );
$opts //= {};
lib/App/Filite/Client.pm view on Meta::CPAN
my $json = encode_json( {
forward => $forward,
} );
my $endpoint = $self->_get_endpoint( 'link' );
my $response = $self->useragent->post(
$endpoint => {
content => $json,
headers => { 'Content-Type' => 'application/json' },
},
);
return sprintf( '%s/%s', $endpoint, $self->_handle_response( $response ) );
}
1;
__END__
view release on metacpan or search on metacpan
script/git-perl view on Meta::CPAN
my $url;
if ( $module =~ /::/ ) {
$url = "https://metacpan.org/pod/$module";
} else {
logger("Getting https://metacpan.org endpoint for '$module'...");
# First, try to find it within recent distributions (the point of this script)
my $test = httpget("https://metacpan.org/recent");
my $urlpart = "";
view release on metacpan or search on metacpan
lib/App/GitGerrit.pm view on Meta::CPAN
set_credentials($username, $password, 'approve');
}
}
if ($Options{debug}) {
my ($endpoint, @args) = @_;
debug "GERRIT->$method($endpoint)";
if (@args) {
require Data::Dumper;
warn Data::Dumper::Dumper(@args);
}
}
view release on metacpan or search on metacpan
lib/App/HistHub.pm view on Meta::CPAN
is => 'rw',
isa => 'ArrayRef',
default => sub { [] },
);
has api_endpoint => (
is => 'rw',
isa => 'Str',
required => 1,
);
lib/App/HistHub.pm view on Meta::CPAN
use App::HistHub;
my $hh = App::HistHub->new(
hist_file => 'path to your history file',
api_endpoint => 'http://localhost:3000/',
);
$hh->run;
=head1 DESCRIPTION
lib/App/HistHub.pm view on Meta::CPAN
=item hist_file
History file path to watch update
=item api_endpoint
Update API URL.
=back
lib/App/HistHub.pm view on Meta::CPAN
=cut
sub uri_for {
my ($self, $path) = @_;
(my $url = $self->api_endpoint) =~ s!/+$!!;
$url . $path;
}
=head2 append_history
lib/App/HistHub.pm view on Meta::CPAN
=cut
sub poe__start {
my ($self, $kernel, $session) = @_[OBJECT, KERNEL, SESSION];
my $d = $self->ua->request( GET $self->api_endpoint . '/api/init' );
$d->addCallback(sub {
my $res = shift;
my $json = $self->json_driver->decode($res->content);
if ($json->{error}) {
view release on metacpan or search on metacpan
lib/App/JobLog/Command/summary.pm view on Meta::CPAN
if ( $t2->{suffix} && $t2->{suffix} eq 'x' ) {
$t2->{hour} += 12;
}
else {
carp '"' . $time
. '" invalid time expression: endpoints out of order';
}
}
delete $t1->{suffix}, delete $t2->{suffix};
return { start => $t1, end => $t2 };
}
view release on metacpan or search on metacpan
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
When streaming sounds, 2 seconds worth of audio data is stored in memory. Although it should work
fine, it's inefficient to use streaming for short sounds. Streaming is useful for things like music
tracks in games.
When you initialize a sound, if you specify a sound group the sound will be attached to that group
automatically. If you set it to NULL, it will be automatically attached to the engine's endpoint.
If you would instead rather leave the sound unattached by default, you can can specify the
`MA_SOUND_FLAG_NO_DEFAULT_ATTACHMENT` flag. This is useful if you want to set up a complex node
graph.
Sounds are not started by default. To start a sound, use `ma_sound_start()`. Stop a sound with
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
miniaudio's routing infrastructure follows a node graph paradigm. The idea is that you create a
node whose outputs are attached to inputs of another node, thereby creating a graph. There are
different types of nodes, with each node in the graph processing input data to produce output,
which is then fed through the chain. Each node in the graph can apply their own custom effects. At
the start of the graph will usually be one or more data source nodes which have no inputs, but
instead pull their data from a data source. At the end of the graph is an endpoint which represents
the end of the chain and is where the final output is ultimately extracted from.
Each node has a number of input buses and a number of output buses. An output bus from a node is
attached to an input bus of another. Multiple nodes can connect their output buses to another
node's input bus, in which case their outputs will be mixed before processing by the node. Below is
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
In the above graph, it starts with two data sources whose outputs are attached to the input of a
splitter node. It's at this point that the two data sources are mixed. After mixing, the splitter
performs it's processing routine and produces two outputs which is simply a duplication of the
input stream. One output is attached to a low pass filter, whereas the other output is attached to
a echo/delay. The outputs of the the low pass filter and the echo are attached to the endpoint, and
since they're both connected to the same input but, they'll be mixed.
Each input bus must be configured to accept the same number of channels, but the number of channels
used by input buses can be different to the number of channels for output buses in which case
miniaudio will automatically convert the input data to the output channel count before processing.
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
if (result != MA_SUCCESS) {
// Failed to initialize node graph.
}
```
When you initialize the node graph, you're specifying the channel count of the endpoint. The
endpoint is a special node which has one input bus and one output bus, both of which have the
same channel count, which is specified in the config. Any nodes that connect directly to the
endpoint must be configured such that their output buses have the same channel count. When you read
audio data from the node graph, it'll have the channel count you specified in the config. To read
data from the graph:
```c
ma_uint32 framesRead;
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
if (result != MA_SUCCESS) {
// Failed to read data from the node graph.
}
```
When you read audio data, miniaudio starts at the node graph's endpoint node which then pulls in
data from it's input attachments, which in turn recusively pull in data from their inputs, and so
on. At the start of the graph there will be some kind of data source node which will have zero
inputs and will instead read directly from a data source. The base nodes don't literally need to
read from a `ma_data_source` object, but they will always have some kind of underlying object that
sources some kind of audio. The `ma_data_source_node` node can be used to read from a
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
returned from `ma_data_source_node_init()`.
By default the node will not be attached to the graph. To do so, use `ma_node_attach_output_bus()`:
```c
result = ma_node_attach_output_bus(&dataSourceNode, 0, ma_node_graph_get_endpoint(&nodeGraph), 0);
if (result != MA_SUCCESS) {
// Failed to attach node.
}
```
The code above connects the data source node directly to the endpoint. Since the data source node
has only a single output bus, the index will always be 0. Likewise, the endpoint only has a single
input bus which means the input bus index will also always be 0.
To detach a specific output bus, use `ma_node_detach_output_bus()`. To detach all output buses, use
`ma_node_detach_all_output_buses()`. If you want to just move the output bus from one attachment to
another, you do not need to detach first. You can just call `ma_node_attach_output_bus()` and it'll
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
| Flag Name | Description |
+-----------------------------------------+---------------------------------------------------+
| MA_NODE_FLAG_PASSTHROUGH | Useful for nodes that do not do any kind of audio |
| | processing, but are instead used for tracking |
| | time, handling events, etc. Also used by the |
| | internal endpoint node. It reads directly from |
| | the input bus to the output bus. Nodes with this |
| | flag must have exactly 1 input bus and 1 output |
| | bus, and both buses must have the same channel |
| | counts. |
+-----------------------------------------+---------------------------------------------------+
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
if (result != MA_SUCCESS) {
// Failed to create node.
}
// Attach your output buses to two different input buses (can be on two different nodes).
ma_node_attach_output_bus(&splitterNode, 0, ma_node_graph_get_endpoint(&nodeGraph), 0); // Attach directly to the endpoint.
ma_node_attach_output_bus(&splitterNode, 1, &myEffectNode, 0); // Attach to input bus 0 of some effect node.
```
The volume of an output bus can be configured on a per-bus basis:
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
wrong moment where the audio thread has just iterated it and has just started processing. The
caller of `ma_node_detach_output_bus()` will stall until the audio thread is finished, which
includes the cost of recursively processing it's inputs. This is the biggest compromise made with
the approach taken by miniaudio for it's lock-free processing system. The cost of detaching nodes
earlier in the pipeline (data sources, for example) will be cheaper than the cost of detaching
higher level nodes, such as some kind of final post-processing endpoint. If you need to do mass
detachments, detach starting from the lowest level nodes and work your way towards the final
endpoint node (but don't try detaching the node graph's endpoint). If the audio thread is not
running, detachment will be fast and detachment in any order will be the same. The reason nodes
need to wait for their input attachments to complete is due to the potential for desyncs between
data sources. If the node was to terminate processing mid way through processing it's inputs,
there's a chance that some of the underlying data sources will have been read, but then others not.
That will then result in a potential desynchronization when detaching and reattaching higher-level
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
struct ma_node_graph
{
/* Immutable. */
ma_node_base base; /* The node graph itself is a node so it can be connected as an input to different node graph. This has zero inputs and calls ma_node_graph_read_pcm_frames() to generate it's output. */
ma_node_base endpoint; /* Special node that all nodes eventually connect to. Data is read from this node in ma_node_graph_read_pcm_frames(). */
ma_uint16 nodeCacheCapInFrames;
/* Read and written by multiple threads. */
MA_ATOMIC(4, ma_bool32) isReading;
};
MA_API ma_result ma_node_graph_init(const ma_node_graph_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_node_graph* pNodeGraph);
MA_API void ma_node_graph_uninit(ma_node_graph* pNodeGraph, const ma_allocation_callbacks* pAllocationCallbacks);
MA_API ma_node* ma_node_graph_get_endpoint(ma_node_graph* pNodeGraph);
MA_API ma_result ma_node_graph_read_pcm_frames(ma_node_graph* pNodeGraph, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
MA_API ma_uint32 ma_node_graph_get_channels(const ma_node_graph* pNodeGraph);
MA_API ma_uint64 ma_node_graph_get_time(const ma_node_graph* pNodeGraph);
MA_API ma_result ma_node_graph_set_time(ma_node_graph* pNodeGraph, ma_uint64 globalTime);
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
{
MA_SOUND_FLAG_STREAM = 0x00000001, /* MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM */
MA_SOUND_FLAG_DECODE = 0x00000002, /* MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE */
MA_SOUND_FLAG_ASYNC = 0x00000004, /* MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC */
MA_SOUND_FLAG_WAIT_INIT = 0x00000008, /* MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT */
MA_SOUND_FLAG_NO_DEFAULT_ATTACHMENT = 0x00000010, /* Do not attach to the endpoint by default. Useful for when setting up nodes in a complex graph system. */
MA_SOUND_FLAG_NO_PITCH = 0x00000020, /* Disable pitch shifting with ma_sound_set_pitch() and ma_sound_group_set_pitch(). This is an optimization. */
MA_SOUND_FLAG_NO_SPATIALIZATION = 0x00000040 /* Disable spatialization. */
} ma_sound_flags;
#ifndef MA_ENGINE_MAX_LISTENERS
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
typedef struct
{
const char* pFilePath; /* Set this to load from the resource manager. */
const wchar_t* pFilePathW; /* Set this to load from the resource manager. */
ma_data_source* pDataSource; /* Set this to load from an existing data source. */
ma_node* pInitialAttachment; /* If set, the sound will be attached to an input of this node. This can be set to a ma_sound. If set to NULL, the sound will be attached directly to the endpoint unless MA_SOUND_FLAG_NO_DEFAULT_ATTACHM...
ma_uint32 initialAttachmentInputBusIndex; /* The index of the input bus of pInitialAttachment to attach the sound to. */
ma_uint32 channelsIn; /* Ignored if using a data source as input (the data source's channel count will be used always). Otherwise, setting to 0 will cause the engine's channel count to be used. */
ma_uint32 channelsOut; /* Set this to 0 (default) to use the engine's channel count. Set to MA_SOUND_SOURCE_CHANNEL_COUNT to use the data source's channel count (only used if using a data source as input). */
ma_uint32 flags; /* A combination of MA_SOUND_FLAG_* flags. */
ma_uint64 initialSeekPointInPCMFrames; /* Initializes the sound such that it's seeked to this location by default. */
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
#if !defined(MA_NO_RESOURCE_MANAGER)
MA_API ma_resource_manager* ma_engine_get_resource_manager(ma_engine* pEngine);
#endif
MA_API ma_device* ma_engine_get_device(ma_engine* pEngine);
MA_API ma_log* ma_engine_get_log(ma_engine* pEngine);
MA_API ma_node* ma_engine_get_endpoint(ma_engine* pEngine);
MA_API ma_uint64 ma_engine_get_time(const ma_engine* pEngine);
MA_API ma_result ma_engine_set_time(ma_engine* pEngine, ma_uint64 globalTime);
MA_API ma_uint32 ma_engine_get_channels(const ma_engine* pEngine);
MA_API ma_uint32 ma_engine_get_sample_rate(const ma_engine* pEngine);
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
0, /* 0 input buses. */
1, /* 1 output bus. */
0 /* Flags. */
};
static void ma_node_graph_endpoint_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
{
MA_ASSERT(pNode != NULL);
MA_ASSERT(ma_node_get_input_bus_count(pNode) == 1);
MA_ASSERT(ma_node_get_output_bus_count(pNode) == 1);
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
ma_copy_pcm_frames(ppFramesOut[0], ppFramesIn[0], *pFrameCountOut, ma_format_f32, ma_node_get_output_channels(pNode, 0));
}
#endif
}
static ma_node_vtable g_node_graph_endpoint_vtable =
{
ma_node_graph_endpoint_process_pcm_frames,
NULL, /* onGetRequiredInputFrameCount */
1, /* 1 input bus. */
1, /* 1 output bus. */
MA_NODE_FLAG_PASSTHROUGH /* Flags. The endpoint is a passthrough. */
};
MA_API ma_result ma_node_graph_init(const ma_node_graph_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_node_graph* pNodeGraph)
{
ma_result result;
ma_node_config baseConfig;
ma_node_config endpointConfig;
if (pNodeGraph == NULL) {
return MA_INVALID_ARGS;
}
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
return result;
}
/* Endpoint. */
endpointConfig = ma_node_config_init();
endpointConfig.vtable = &g_node_graph_endpoint_vtable;
endpointConfig.pInputChannels = &pConfig->channels;
endpointConfig.pOutputChannels = &pConfig->channels;
result = ma_node_init(pNodeGraph, &endpointConfig, pAllocationCallbacks, &pNodeGraph->endpoint);
if (result != MA_SUCCESS) {
ma_node_uninit(&pNodeGraph->base, pAllocationCallbacks);
return result;
}
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
{
if (pNodeGraph == NULL) {
return;
}
ma_node_uninit(&pNodeGraph->endpoint, pAllocationCallbacks);
}
MA_API ma_node* ma_node_graph_get_endpoint(ma_node_graph* pNodeGraph)
{
if (pNodeGraph == NULL) {
return NULL;
}
return &pNodeGraph->endpoint;
}
MA_API ma_result ma_node_graph_read_pcm_frames(ma_node_graph* pNodeGraph, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
{
ma_result result = MA_SUCCESS;
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
if (pNodeGraph == NULL) {
return MA_INVALID_ARGS;
}
channels = ma_node_get_output_channels(&pNodeGraph->endpoint, 0);
/* We'll be nice and try to do a full read of all frameCount frames. */
totalFramesRead = 0;
while (totalFramesRead < frameCount) {
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
framesToRead = 0xFFFFFFFF;
}
ma_node_graph_set_is_reading(pNodeGraph, MA_TRUE);
{
result = ma_node_read_pcm_frames(&pNodeGraph->endpoint, 0, (float*)ma_offset_pcm_frames_ptr(pFramesOut, totalFramesRead, ma_format_f32, channels), (ma_uint32)framesToRead, &framesJustRead, ma_node_get_time(&pNodeGraph->endpoint));
}
ma_node_graph_set_is_reading(pNodeGraph, MA_FALSE);
totalFramesRead += framesJustRead;
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
{
if (pNodeGraph == NULL) {
return 0;
}
return ma_node_get_output_channels(&pNodeGraph->endpoint, 0);
}
MA_API ma_uint64 ma_node_graph_get_time(const ma_node_graph* pNodeGraph)
{
if (pNodeGraph == NULL) {
return 0;
}
return ma_node_get_time(&pNodeGraph->endpoint); /* Global time is just the local time of the endpoint. */
}
MA_API ma_result ma_node_graph_set_time(ma_node_graph* pNodeGraph, ma_uint64 globalTime)
{
if (pNodeGraph == NULL) {
return MA_INVALID_ARGS;
}
return ma_node_set_time(&pNodeGraph->endpoint, globalTime); /* Global time is just the local time of the endpoint. */
}
#define MA_NODE_OUTPUT_BUS_FLAG_HAS_READ 0x01 /* Whether or not this bus ready to read more data. Only used on nodes with multiple output buses. */
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
}
#endif
}
}
MA_API ma_node* ma_engine_get_endpoint(ma_engine* pEngine)
{
return ma_node_graph_get_endpoint(&pEngine->nodeGraph);
}
MA_API ma_uint64 ma_engine_get_time(const ma_engine* pEngine)
{
return ma_node_graph_get_time(&pEngine->nodeGraph);
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
{
if (pEngine == NULL) {
return MA_INVALID_ARGS;
}
return ma_node_set_output_bus_volume(ma_node_graph_get_endpoint(&pEngine->nodeGraph), 0, volume);
}
MA_API ma_result ma_engine_set_gain_db(ma_engine* pEngine, float gainDB)
{
if (pEngine == NULL) {
return MA_INVALID_ARGS;
}
return ma_node_set_output_bus_volume(ma_node_graph_get_endpoint(&pEngine->nodeGraph), 0, ma_volume_db_to_linear(gainDB));
}
MA_API ma_uint32 ma_engine_get_listener_count(const ma_engine* pEngine)
{
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
if (pEngine == NULL || pFilePath == NULL) {
return MA_INVALID_ARGS;
}
/* Attach to the endpoint node if nothing is specicied. */
if (pNode == NULL) {
pNode = ma_node_graph_get_endpoint(&pEngine->nodeGraph);
nodeInputBusIndex = 0;
}
/*
We want to check if we can recycle an already-allocated inlined sound. Since this is just a
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
result = ma_engine_node_init(&engineNodeConfig, &pEngine->allocationCallbacks, &pSound->engineNode);
if (result != MA_SUCCESS) {
return result;
}
/* If no attachment is specified, attach the sound straight to the endpoint. */
if (pConfig->pInitialAttachment == NULL) {
/* No group. Attach straight to the endpoint by default, unless the caller has requested that do not. */
if ((pConfig->flags & MA_SOUND_FLAG_NO_DEFAULT_ATTACHMENT) == 0) {
result = ma_node_attach_output_bus(pSound, 0, ma_node_graph_get_endpoint(&pEngine->nodeGraph), 0);
}
} else {
/* An attachment is specified. Attach to it by default. The sound has only a single output bus, and the config will specify which input bus to attach to. */
result = ma_node_attach_output_bus(pSound, 0, pConfig->pInitialAttachment, pConfig->initialAttachmentInputBusIndex);
}
view release on metacpan or search on metacpan
0.04 2016/09/14 21:02:35
[CHANGES]
* Initial attempt at a 'client' subcommand structure; added
'client json' and 'client login'
* Added 'directory' command for interfacing with public directory
endpoints
[BUGFIXES]
* Actually respect IPv4/IPv6 family restriction
0.03 2016/03/14 14:24:29
view release on metacpan or search on metacpan
lib/App/MultiModule/Tasks/OutOfBand.pm view on Meta::CPAN
$oob_message->{oob_tags}->{message}->{$key} = $value
if not ref $value;
}
}
}
if($filter_config and $filter_config->{transit_endpoints}) {
while(my($transit_name, $transit_def) = each %{$filter_config->{transit_endpoints}}) {
if($transit_def->{destination}) {
IPC::Transit::send(
qname => $transit_def->{qname},
message => $oob_message,
destination => $transit_def->{destination}
view release on metacpan or search on metacpan
lib/ChordPro/lib/SVGPDF/Contrib/Bogen.pm view on Meta::CPAN
and y radii, with the two intersection points as inputs. There are four
possible resulting arcs, which can be selected with opts C<large> and C<dir>.
This extends the path along an arc of an ellipse of the specified x and y radii
between C<[$x1,$y1]> to C<[$x2,$y2]>. The current position is then set
to the endpoint of the arc (C<[$x2,$y2]>).
Options (C<@opts>)
=over
lib/ChordPro/lib/SVGPDF/Contrib/Bogen.pm view on Meta::CPAN
# input: x and y axis radii
# sweep start and end angles (degrees)
# sweep direction (0=CCW (default), or 1=CW)
# axis rotation (radians, + = CCW, default = 0)
# output: two endpoints and two control points for
# the Bezier curve describing the arc
# maximum 30 degrees of sweep: is broken up into smaller
# arc segments if necessary
# if crosses 0 degree angle in either sweep direction, split there at 0
# if alpha=beta (0 degree sweep) or either radius <= 0, fatal error
lib/ChordPro/lib/SVGPDF/Contrib/Bogen.pm view on Meta::CPAN
radius, with the two intersection points as inputs. There are B<four> possible
resulting arcs, which can be selected with C<$larger> and C<$reverse>.)
This extends the path along an arc of a circle of the specified radius
between C<[$x1,$y1]> to C<[$x2,$y2]>. The current position is then set
to the endpoint of the arc (C<[$x2,$y2]>).
Set C<$move> to a I<true> value if this arc is the beginning of a new
path instead of the continuation of an existing path. Note that the default
(C<$move> = I<false>) is
I<not> a straight line to I<P1> and then the arc, but a blending into the curve
view release on metacpan or search on metacpan
public/javascripts/ace/mode-php.js view on Meta::CPAN
"bool socket_connect(resource socket, string addr [, int port])",
"Opens a connection to addr:port on the socket specified by socket"
],
"socket_create": [
"resource socket_create(int domain, int type, int protocol)",
"Creates an endpoint for communication in the domain specified by domain, of type specified by type"
],
"socket_create_listen": [
"resource socket_create_listen(int port[, int backlog])",
"Opens a socket on port to accept connections"
],
view release on metacpan or search on metacpan
lib/App/Netdisco/Util/Web.pm view on Meta::CPAN
=head1 EXPORT_OK
=head2 request_is_api
Client has requested JSON format data and an endpoint under C</api>.
=cut
sub request_is_api {
return ((request->accept and request->accept =~ m/(?:json|javascript)/) and (
view release on metacpan or search on metacpan
script/peri-htserve view on Meta::CPAN
}
}
# display hint for user
if (@root_urls) {
my @ep_urls; # api endpoints
for my $root_url (@root_urls) {
for my $pkg (@pkgs) {
my $pkgp = $pkg; $pkgp =~ s!::!/!g;
push @ep_urls, $root_url . "api/$pkgp/";
}
view release on metacpan or search on metacpan
t/cpan/Mojo2/UserAgent.pm view on Meta::CPAN
sub _connect {
my ( $self, $loop, $tx, $handle ) = @_;
my $t = $self->transactor;
my ( $proto, $host, $port ) =
$handle ? $t->endpoint( $tx ) : $t->peer( $tx );
my %options = ( timeout => $self->connect_timeout );
if ( $proto eq 'http+unix' ) { $options{path} = $host }
else { @options{qw(address port)} = ( $host, $port ) }
$options{socket_options} = $self->socket_options;
$options{handle} = $handle if $handle;
# SOCKS
if ( $proto eq 'socks' ) {
@options{qw(socks_address socks_port)} = @options{qw(address port)};
( $proto, @options{qw(address port)} ) = $t->endpoint( $tx );
my $userinfo = $tx->req->via_proxy( 0 )->proxy->userinfo;
@options{qw(socks_user socks_pass)} = split /:/, $userinfo if $userinfo;
}
# TLS
t/cpan/Mojo2/UserAgent.pm view on Meta::CPAN
sub _connection {
my ( $self, $loop, $tx, $cb ) = @_;
# Reuse connection
my ( $proto, $host, $port ) = $self->transactor->endpoint( $tx );
my $id;
if ( $id = $self->_dequeue( $loop, "$proto:$host:$port", 1 ) ) {
warn "-- Reusing connection $id ($proto://$host:$port)\n" if DEBUG;
@{ $self->{connections}{$id} }{qw(cb tx)} = ( $cb, $tx );
$tx->kept_alive( 1 ) unless $tx->connection;
t/cpan/Mojo2/UserAgent.pm view on Meta::CPAN
if $close || !$tx || !$max || !$tx->keep_alive || $tx->error;
# Keep connection alive
my $queue = $self->{queue}{ $c->{ioloop} } //= [];
$self->_remove( shift( @$queue )->[1] ) while @$queue && @$queue >= $max;
push @$queue, [ join( ':', $self->transactor->endpoint( $tx ) ), $id ];
}
sub _start {
my ( $self, $loop, $tx, $cb ) = @_;
view release on metacpan or search on metacpan
lib/App/Presto.pm view on Meta::CPAN
return App::Presto::Client->new(config => $self->config);
}
has config => (
is => 'rw',
handles => ['endpoint'],
);
has _stash => (
is => 'lazy',
handles => ['stash'],
lib/App/Presto.pm view on Meta::CPAN
args => "[-c] [-d] [number]",
method => sub { shift->history_call(@_) },
doc => "Specify a number to list the last N lines of history Pass -c to clear the command history, -d NUM to delete a single item\n",
},
},
prompt => sprintf( '%s> ', $self->endpoint ),
history_file => $self->config->file('history'),
);
$term->ornaments('md,me,,');
return $term;
}
lib/App/Presto.pm view on Meta::CPAN
sub run {
my $class = shift;
my $self = $class->instance;
my @args = shift;
my $config;
if(my $endpoint = shift(@args)){
$self->config( $config = App::Presto::Config->new( endpoint => $endpoint ) );
} else {
die "Base endpoint (i.e. http://some-host.com) must be specified as command-line argument\n";
}
$config->init_defaults;
$self->command_factory->install_commands($self);
view release on metacpan or search on metacpan
bin/proxy_that view on Meta::CPAN
=head1 DESCRIPTION
This utility starts a L<Plack> based proxy server that forwards requests
to one URL. It can create a throw-away SSL certificate and run over https,
which makes it easy to provide encrypted endpoints for local development
if your frontend has to run on https.
=head1 OPTIONS
The following options are available:
view release on metacpan or search on metacpan
lib/App/RoboBot/Plugin/API/Github.pm view on Meta::CPAN
my ($self, $repo) = @_;
# Update repo with polled_at = now() - 10 seconds, so that every time we
# poll GH, we're actually looking at a window of length(watcher_interval)
# offset 10 seconds in the past. This gives events on the GH side of things
# time to propogate to their API endpoints, so we don't miss out.
my $poll_t = $self->bot->config->db->do(q{
update github_repos
set polled_at = now() - interval '10 seconds'
where repo_id = ?
returning to_char(polled_at at time zone 'UTC','YYYY-MM-DD"T"HH24:MI:SS"Z"') as polled_at
view release on metacpan or search on metacpan
lib/App/SeismicUnixGui/sunix/transform/sugabor.pm view on Meta::CPAN
Optional parameters:
dt=(from header) time sampling interval (sec)
fmin=0 minimum frequency of filter array (hz)
fmax=NYQUIST maximum frequency of filter array (hz)
beta=3.0 ln[filter peak amp/filter endpoint amp]
band=.05*NYQUIST filter bandwidth (hz)
alpha=beta/band^2 filter width parameter
verbose=0 =1 supply additional info
holder=0 =1 output Holder regularity estimate
=2 output linear regularity estimate
view release on metacpan or search on metacpan
lib/App/Spoor/Config.pm view on Meta::CPAN
transformer: bin/login_log_transformer.pl
transmission:
credentials:
api_identifier: api_identifier_goes_here
api_secret: api_secret_goes_here
endpoints:
report: /api/reports
host: https://spoor.capefox.co
=head1 SUBROUTINES/METHODS
view release on metacpan or search on metacpan
examples/complex/lib/App/Standby/Cmd/Command/complex.pm view on Meta::CPAN
App::Standby::Cmd::Command::complex - Example for a command to be run as a cronjob
=head1 DESCRIPTION
This class implements an example for a cronjob that is run once a day to keep some
complex endpoint up-to-date.
=cut
view release on metacpan or search on metacpan
lib/App/TimeTracker/Command/Gitlab.pm view on Meta::CPAN
return $user->{id} if $user && $user->{id};
return;
}
sub _call {
my ($self,$method, $endpoint, $args) = @_;
my $url = $self->config->{gitlab}{url}.'/api/v4/'.$endpoint;
my $res = $self->gitlab_client->request($method,$url);
if ($res->{success}) {
my $data = decode_json($res->{content});
return $data;
}
view release on metacpan or search on metacpan
lib/App/TimeTracker/Command/Trello.pm view on Meta::CPAN
$self->config->{_used_config_files}->[0], 'local' );
}
}
sub _do_trello {
my ( $self, $method, $endpoint, @args ) = @_;
my $client = $self->trello_client;
exit 1 unless $client;
my $res = $client->$method( $endpoint, @args );
if ( $res->failed ) {
error_message(
"Cannot talk to Trello API: " . $res->error . ' ' . $res->code );
if ( $res->code == 401 ) {
say "Maybe running 'tracker setup_trello' will help...";
view release on metacpan or search on metacpan
lib/App/WatchLater/YouTube.pm view on Meta::CPAN
} => $class;
}
=head2 request
my $body = $api->request($method, $endpoint, %params);
Send a request to the specified API endpoint using the given HTTP method. Query
parameters may be specified in C<%params>. Croaks if the request fails.
=cut
sub request {
my ($self, $method, $endpoint, %params) = @_;
my $url = 'https://www.googleapis.com/youtube/v3' . $endpoint;
my %headers;
if (defined $self->{token}) {
$headers{Authorization} = 'Bearer ' . $self->{token};
view release on metacpan or search on metacpan
lib/App/coinbasepro/lite.pm view on Meta::CPAN
use Log::ger;
our %SPEC;
my %args_common = (
endpoint => {
schema => 'str*', # XXX uri
req => 1,
pos => 0,
},
args => {
lib/App/coinbasepro/lite.pm view on Meta::CPAN
sub public {
my %args = @_;
_init(\%args);
$clipub->public_request(
$args{method},
$args{endpoint},
$args{args},
);
}
$SPEC{private} = {
lib/App/coinbasepro/lite.pm view on Meta::CPAN
sub private {
my %args = @_;
_init(\%args);
$clipriv->private_request(
$args{method},
$args{endpoint},
$args{args},
);
}
1;
lib/App/coinbasepro/lite.pm view on Meta::CPAN
=over 4
=item * B<args> => I<hash>
=item * B<endpoint>* => I<str>
=item * B<key>* => I<str>
=item * B<method> => I<str> (default: "GET")
lib/App/coinbasepro/lite.pm view on Meta::CPAN
=over 4
=item * B<args> => I<hash>
=item * B<endpoint>* => I<str>
=item * B<method> => I<str> (default: "GET")
=back
view release on metacpan or search on metacpan
bin/colorcoke view on Meta::CPAN
my $DEBUG = $ENV{DEBUG};
our($opt_r_step, $opt_g_step, $opt_b_step) = (10) x 3;
our $opt_hex = '000000';
our $opt_starting_point = 17; # Start from 17
our $opt_endpoint = 231; # End at 231
our $opt_ansi_only = 0;
our $opt_random = 0;
our $opt_random_r = 256;
our $opt_random_g = 256;
our $opt_random_b = 256;
bin/colorcoke view on Meta::CPAN
'r|red:i' => \$opt_r_step,
'g|green:i' => \$opt_g_step,
'b|blue:i' => \$opt_b_step,
'1|single:s{2}' => \@opt_single_color,
's|start:i' => \$opt_starting_point,
'end:i' => \$opt_endpoint,
'ansi' => \$opt_ansi_only,
'random' => \$opt_random,
'rr|rand-red:i' => \$opt_random_r,
'rg|rand-green:i' => \$opt_random_g,
'rb|rand-blue:i' => \$opt_random_b,
bin/colorcoke view on Meta::CPAN
$r = hex($r);
$g = hex($g);
$b = hex($b);
$opt_starting_point = 0 if($opt_starting_point == 1); # Include ANSI
$opt_endpoint = 255 if($opt_endpoint == 1); # Include greyscale
if($opt_ansi_only) {
$opt_starting_point = 0;
$opt_endpoint = 16;
}
for ($opt_starting_point .. $opt_endpoint) {
if($opt_random) {
$r = int(rand($opt_random_r) % 256);
$g = int(rand($opt_random_g) % 256);
view release on metacpan or search on metacpan
1.59_06 Tue Feb 5 12:36:00 PST 2013
[Incompatible Changes]
- --mirror-index option doesn't automatically assume --mirror-only
[Improvements]
- Use versioned MetaCPAN API endpoint (oalders)
1.59_05 Mon Feb 4 11:49:40 PST 2013
[New Features]
- Support version ranges in command args and cpanfile queried agsinst MetaCPAN
with the proper version range query to get the best version that satisfies
view release on metacpan or search on metacpan
share/wordlist_en.tsv view on Meta::CPAN
25321 endnote
25322 endocrine
25323 endorphin
25324 endorse
25325 endowment
25326 endpoint
25331 endurable
25332 endurance
25333 enduring
25334 energetic
25335 energize
view release on metacpan or search on metacpan
share/man/man1/git-hub.1 view on Meta::CPAN
.Ve
.PP
to trust a list of users in one go.
.SH "Token Authentication and Scopes"
.IX Header "Token Authentication and Scopes"
Many endpoints of the GitHub v3 \s-1API\s0 require a Personal \s-1API\s0 Access Token. You can list your current tokens with this command:
.PP
.Vb 1
\& git hub tokens
.Ve
.PP
view release on metacpan or search on metacpan
currently it works with:
* fixed, hardcoded list of packages names
* Github GraphQL endpoint
view release on metacpan or search on metacpan
favor of App-cryp-exchange.
- Maintain list of pairs in App::cryp::Exchange::indodax instead of in
our dist.
- Update/fix API endpoint URL.
0.023 2018-04-06 (PERLANCAR)
- Add new pairs: ada_idr, bcd_idr.