Result:
found more than 659 distributions - search limited to the first 2001 files matching your query
( run in 0.958 )
App-Chorus
view release on metacpan or search on metacpan
This file contains message digests of all files listed in MANIFEST,
signed via the Module::Signature module, version 0.73.
To verify the content in this distribution, first make sure you have
Module::Signature installed, then type:
% cpansign -v
It will check each file's integrity, as well as the signature's
App-Chronicle
view release on metacpan or search on metacpan
t/test-archive-links.t view on Meta::CPAN
$data{ 'date' } = scalar( localtime() );
#
# Run through the plugin and verify the link has a date-prefix now
#
my $out = Chronicle::Plugin::Archived::on_insert( undef, data => \%data );
#
App-Cme
view release on metacpan or search on metacpan
This file contains message digests of all files listed in MANIFEST,
signed via the Module::Signature module, version 0.96.
To verify the content in this distribution, first make sure you have
Module::Signature installed, then type:
% cpansign -v
It will check each file's integrity, as well as the signature's
App-Context
view release on metacpan or search on metacpan
lib/App/installguide/hosted.pod view on Meta::CPAN
'keep_source_where' => q[/home/username/.cpan/sources],
'makepl_arg' => q[PREFIX=/home/username],
'make_install_arg' => q[],
'mbuildpl_arg' => q[install_base=/home/username],
Then fire up the CPAN shell and install something. Then verify that it installed.
# perl -MCPAN -e shell
cpan> install App::Options
cpan> exit
# find ~/lib -name Options.pm -print
App-CriticDB
view release on metacpan or search on metacpan
lib/App/CriticDB.pm view on Meta::CPAN
Violations are stored together with the current I<mtime> for each file. On subsequent scans, files will be skipped unless their on-disk I<mtime> exceeds the previous value.
=head2 File deletions
The collector will re-verify the existence of all files at the beginning of each run. Files that no longer exist are removed from the datastore.
=head1 TODO
=head2 Collection
App-DHCPClientUtils
view release on metacpan or search on metacpan
scripts/multi-homed-routing.pl view on Meta::CPAN
[% END %]
[% END %]
# Helper functions
function verify_ip() {
local IP
local device=\\\$1
local IP_in=\\\$2
IP=\\\$(\\\$IP_TOOL -4 -o addr show dev \\\$device 2> /dev/null)
scripts/multi-homed-routing.pl view on Meta::CPAN
fail_cnt=0
[% FOREACH if IN interfaces %]
# Check interface [% if.device %]
verify_ip \\\$IF[% if.table %]_DEVICE \\\$IF[% if.table %]_IP
if [ \\\$? -eq 0 ]; then
# Add table [% if.table %] for interface [% if.device %]
\\\$IP_TOOL route flush table [% if.table %]
App-DWG-Sort
view release on metacpan or search on metacpan
This file contains message digests of all files listed in MANIFEST,
signed via the Module::Signature module, version 0.87.
To verify the content in this distribution, first make sure you have
Module::Signature installed, then type:
% cpansign -v
It will check each file's integrity, as well as the signature's
App-Daemon
view release on metacpan or search on metacpan
...
=item stop
will find the daemon's PID in the pidfile and send it a SIGTERM signal. It
will verify $App::Daemon::kill_retries times if the process is still alive,
with 1-second sleeps in between.
To have App::Daemon send a different signal than SIGTERM (e.g., SIGINT), set
use POSIX;
App-Deps-Verify
view release on metacpan or search on metacpan
lib/App/Deps/Verify.pm view on Meta::CPAN
my ( $self, $args ) = @_;
return [ map { LoadFile($_) } @{ $args->{filenames} } ];
}
sub verify_deps_in_yamls
{
my ( $self, $args ) = @_;
return $self->find_deps(
{
lib/App/Deps/Verify.pm view on Meta::CPAN
=encoding UTF-8
=head1 NAME
App::Deps::Verify - app and API to verify the presence of dependencies (Perl 5 modules, python3 modules, executables, etc.)
=head1 VERSION
version 0.12.2
=head1 SYNOPSIS
use App::Deps::Verify ();
App::Deps::Verify->new->verify_deps_in_yamls(
+{ filenames => [ $opt->{input}, ] } );
path( $opt->{output} )->spew_utf8("Success!");
Command-line usage:
lib/App/Deps/Verify.pm view on Meta::CPAN
help: display a command's help screen
plinst: install perl5 dependencies from CPAN
plupdatetask: update a Task::Weaver perl5 dependencies Task
py3list: list python3 dependencies from PyPI
verify: verify the presence of dependencies
=head1 DESCRIPTION
Here are some examples for YAML input files:
lib/App/Deps/Verify.pm view on Meta::CPAN
=back
=head1 METHODS
=head2 $obj->verify_deps_in_yamls({filenames => [@FILENAMES]})
Verify the presence of deps in all the YAML files.
=head2 $obj->find_deps({inputs => [\%hash1, \%hash2, ...]})
lib/App/Deps/Verify.pm view on Meta::CPAN
=back
=head2 Bugs / Feature Requests
Please report any bugs or feature requests by email to C<bug-app-deps-verify at rt.cpan.org>, or through
the web interface at L<https://rt.cpan.org/Public/Bug/Report.html?Queue=App-Deps-Verify>. You will be automatically notified of any
progress on the request by the system.
=head2 Source Code
lib/App/Deps/Verify.pm view on Meta::CPAN
Shlomi Fish <shlomif@cpan.org>
=head1 BUGS
Please report any bugs or feature requests on the bugtracker website
L<https://github.com/shlomif/app-deps-verify/issues>
When submitting a bug or request, please include a test-file or a
patch to an existing test-file that illustrates the bug or desired
feature.
App-Dest
view release on metacpan or search on metacpan
lib/App/Dest.pm view on Meta::CPAN
$ext = '.' . $ext if ( defined $ext );
$ext //= '';
try {
mkpath($path);
for ( qw( deploy verify revert ) ) {
open( my $file, '>', "$path/$_$ext" ) or die;
print $file "\n";
}
}
catch ($e) {
lib/App/Dest.pm view on Meta::CPAN
}
sub expand {
my ( $self, $path ) = @_;
print join( ' ', map { <"$path/$_*"> } qw( deploy verify revert ) ), "\n";
return 0;
}
sub list {
lib/App/Dest.pm view on Meta::CPAN
$self->revert($action);
return $self->deploy($action);
}
sub verify {
my $self = _new(shift);
my ($action) = @_;
return $self->_execute_action( $self->_build_execute_stack( $action, 'verify' )->[0] );
}
sub revert {
my $self = _new(shift);
my ( $dry_run, $action ) = _dry_check(@_);
lib/App/Dest.pm view on Meta::CPAN
deployed => 0,
},
);
}
elsif ( $a and $b ) {
( my $action = $b ) =~ s,/(?:deploy|verify|revert)(?:\.[^\/]+)?$,,;
push(
@{ $data->{actions} },
{
action => $action,
modified => 1,
lib/App/Dest.pm view on Meta::CPAN
wrap => $wraps->{$action},
},
);
if ( $type eq 'deploy' ) {
my $verify_file = ( <"$action/verify*"> )[0];
die "Action file does not exist for: verify $action\n" unless ($verify_file);
splice(
@execute_stack,
1,
0,
{
type => 'verify',
action => $action,
file => $verify_file,
wrap => $wraps->{$action},
},
);
}
};
lib/App/Dest.pm view on Meta::CPAN
$add->() unless ( $state->{$action}{deployed} and not $redeploy );
}
elsif ( $type eq 'revert' ) {
$add->() if ( $state->{$action}{deployed} or $state->{$action}{modified} );
}
elsif ( $type eq 'verify' ) {
$add->();
}
}
return \@execute_stack;
lib/App/Dest.pm view on Meta::CPAN
warn "Warnings from executed $file: $err_str\n";
}
}
};
if ( $type eq 'verify' ) {
$run->();
chomp($out);
die "$err\n" if ($err);
if ($out) {
print "ok - verify: $action\n";
}
else {
die "not ok - verify: $action\n";
}
}
else {
print "begin - $type: $action\n";
$run->();
print "ok - $type: $action\n";
}
my $dest_copy = $self->_rel2dir( '.dest/' . $self->_rel2root($action) );
rmtree($dest_copy) unless ( $type eq 'verify' );
dircopy( $action, $dest_copy ) if ( $type eq 'deploy' );
return 0;
}
lib/App/Dest.pm view on Meta::CPAN
dest clean [NAME] # reset dest state to match current files/dirs
dest preinstall [NAME] # set dest state so an update will deploy everything
dest nuke # de-initialize dest; remove all dest stuff
dest deploy NAME [-d] # deployment of a specific action
dest verify [NAME] # verification of tracked actions or specific action
dest revert NAME [-d] # revertion of a specific action
dest redeploy NAME [-d] # deployment of a specific action
dest revdeploy NAME # revert and deployment of a specific action
dest update [INCS] [-d] # automaticall deploy or revert to cause currency
lib/App/Dest.pm view on Meta::CPAN
=head1 DESCRIPTION
C<dest> is a simple "deployment state" change management tool. Inspired by
what Sqitch does for databases, it provides a simple mechanism for writing
deploy, verify, and revert parts of a change action. The typical use of
C<dest> is in a development context because it allows for simplified state
changes when switching between branches (as an example).
Let's say you're working with a group of other software engineers on a
particular software project using your favorite revision control system.
lib/App/Dest.pm view on Meta::CPAN
installation of libraries or other applications. Then let's also say the team
branches, works on stuff, shares those branches, reverts, merges, etc. And also
from time to time you want to go back in time a bit so you can reproduce a bug.
Maintaining the database state and the state of the system across all that
activity can be problematic. C<dest> tries to solve this in a very simple way,
letting you be able to deploy, revert, and verify to any point in time in
the development history.
See below for an example scenario that may help illustrate using C<dest> in a
pseudo real world situation.
lib/App/Dest.pm view on Meta::CPAN
=head2 add DIR
Once a project has been initialized, you need to tell C<dest> what directories
you want to "track". Into these tracked directories you'll place subdirectories
with recognizable names, and into each subdirectory a set of 3 files: deploy,
revert, and verify.
For example, let's say you have a database. So you create C<db> in your
project's root directory. Then call C<dest add db> from your root directory.
Inside C<db>, you might create the directory C<db/schema>. And under that
directory, add the files: deploy, revert, and verify.
The deploy file contains the instructions to create the database schema. The
revert file contains the instructions to revert what the deploy file did. And
the verify file let's you verify the deploy file worked.
=head2 rm DIR
This removes a directory from the C<dest> tracking list.
lib/App/Dest.pm view on Meta::CPAN
contents of the currently watched directories.
=head2 make NAME [EXT]
This is a helper command. Given a directory you've already added, it will create
the subdirectory and deploy, revert, and verify files.
# given db, creates db/schema and the 3 files
dest make db/schema
As a nice helper bit, C<make> will list the relative paths of the 3 new files.
lib/App/Dest.pm view on Meta::CPAN
vi `dest make db/schema sql`
# this will create and open in vi:
# db/schema/deploy.sql
# db/schema/revert.sql
# db/schema/verify.sql
And optionally, you can include any date/time format supported by L<POSIX>
C<strftime>.
dest make db/%s_action sql
lib/App/Dest.pm view on Meta::CPAN
want to:
dest deploy db/new_function
Note that you shouldn't add "/deploy" to the end of that. Also note that a
C<deploy> call will automatically call C<verify> when complete.
Adding a "-d" flag to the command will cause a "dry run" to run, which will
not perform any actions but will instead report what actions would happen.
=head2 verify [NAME]
This will run the verify step on any given action, or if no action name is
provided, all actions under directories that are tracked.
Unlike deploy and revert files, which can run the user through all sorts of
user input/output, verify files must return some value that is either true
or false. C<dest> will assume that if it sees a true value, verification is
confirmed. If it receives a false value, verification is assumed to have failed.
=head2 revert NAME [-d]
lib/App/Dest.pm view on Meta::CPAN
the code, they will be reverted.
If there are actions that are in the code that have been deployed, but the
"deploy" file has changed, then C<update> will revert the previously deployed
"deploy" file then deploy the new "deploy" file. (And note that the deployment
will automatically call C<verify>.)
You can optionally add one or more "INCS" strings to the update command to
restrict the update to only perform operations that include one of the "INCS" in
its action file. So for example, let's say you have a "db/changes" directory
with some actions and a "etc/changes" directory with some actions. If you were
lib/App/Dest.pm view on Meta::CPAN
example/
ls/
deploy
revert
verify
Let's then also say that the C<example/ls/deploy> file contains: C<ls>
I could create a deployment file C<example/dest.wrap> that looked like this:
lib/App/Dest.pm view on Meta::CPAN
point in time prior to the revert file existing, C<dest> maintains a copy of the
original revert file so it can revert the action. However, it will always rely
on whatever wrapper is in the current working directory.
The C<dest.wrap> is called with two parameters: first, the name of the change
program, and second, the action type ("deploy", "revert", "verify").
=head1 WATCH FILE
Optionally, you can elect to use a watch file that can be committed to your
favorite revision control system. In the root directory of your project, create
lib/App/Dest.pm view on Meta::CPAN
dest status # show the current status (which is everything is OK)
=head2 Create Schema Action
The next step would probably be to create your database schema as a C<dest>
action. Actions include deploy, verify, and revert files. You can use the "make"
command to create these files for you. The command will return the list of files
created, so you can wrap the command to your favorite editor.
dest make db/schema sql # create "schema" action as ".sql" files
vi `dest list db/schema` # list the "schema" files into vi
vi `dest make db/schema sql` # the previous 2 commands as 1 command
Your deploy file will be the SQL required to create your schema. The revert file
reverts what the deploy file deploys. The verify file needs to return some
positive value if and only if the deploy action worked.
Since your local CLI shell probably doesn't know how to execute SQL files
natively, you'll likely need to create a C<dest.wrap> file.
touch db/dest.wrap && chmod u+x db/dest.wrap && vi db/dest.wrap
This file if it exists will get executed instead of the deploy, verify, and
revert files, and it will be passed the action file being executed.
=head2 Status and Deploying
Now, check the project's C<dest> status:
App-Devbot
view release on metacpan or search on metacpan
This file contains message digests of all files listed in MANIFEST,
signed via the Module::Signature module, version 0.73.
To verify the content in this distribution, first make sure you have
Module::Signature installed, then type:
% cpansign -v
It will check each file's integrity, as well as the signature's
App-DistSync
view release on metacpan or search on metacpan
lib/App/DistSync.pm view on Meta::CPAN
$ua->timeout($to) if $to;
$ua->agent(sprintf("%s/%s", __PACKAGE__, $VERSION));
$ua->env_proxy;
$ua->proxy(['http', 'https'] => $props{proxy}) if $props{proxy};
$ua->ssl_opts(
verify_hostname => 0,
SSL_verify_mode => 0x00
) if $props{insecure};
return $self;
}
sub verbose { !!shift->{verbose} }
App-DocKnot
view release on metacpan or search on metacpan
t/data/generate/control-archive/docknot.yaml view on Meta::CPAN
* All of the configuration used to generate a `control.ctl` file for INN
and the `PGPKEYS` and `README.html` files distributed with pgpcontrol,
along with the script to generate those files.
* Software to process control messages, verify them against that
authorization information, and maintain a control message archive and
list of active newsgroups. Software is also included to generate
reports of recent changes to the list of active newsgroups.
* The documentation files included in the control message archive and
App-Dochazka-CLI
view release on metacpan or search on metacpan
0.042 2014-10-29 16:40 CET
- Parser.pm: support "/activity/code/:code"
0.043 2014-10-29 22:53 CET
- Parser.pm: support POST on 'activity/aid/:aid' and 'activity/code/:code',
even if just to verify 405 result
0.044 2014-10-30 18:20 CET
- Parser.pm: support 'activity/aid' and 'activity/code' resources
0.045 2014-10-31 21:20 CET
App-Dochazka-Common
view release on metacpan or search on metacpan
t/model/reset.t view on Meta::CPAN
my $testobj = $full_class->spawn( %{ $props_dispatch{$cl} } );
note( 'reset it' );
$testobj->reset;
note( 'verify that we have all the properties right' );
foreach my $prop ( @{ $full_class->attrs } ) {
note( "Property $prop" );
ok( exists( $props_dispatch{$cl}->{$prop} ) );
}
my %attrs;
map { $attrs{$_} = ''; } @{ $full_class->attrs };
foreach my $prop ( keys( %{ $props_dispatch{$cl} } ) ) {
ok( exists( $attrs{$prop} ) );
}
note( 'verify that all properties have been set to undef' );
foreach my $prop ( @{ $full_class->attrs } ) {
is( $testobj->{$prop}, undef );
}
}
App-Dochazka-REST
view release on metacpan or search on metacpan
lib/App/Dochazka/REST/Docs/Resources.pm view on Meta::CPAN
Allowed methods: POST
Given a set of intervals, all of which must fall within a single contiguous
168-hour (7-day) period, this resource performs all actions necessary to either
create a new schedule from those intervals or verify that an equivalent
schedule already exists.
Sample JSON:
{ "schedule" : [
App-Docker-Client
view release on metacpan or search on metacpan
lib/App/Docker/Client.pm view on Meta::CPAN
want_body_handle => 1,
(
$self->ssl_opts
? (
tls_ctx => {
verify => 1,
verify_peername => "https",
ca_file => $self->{ssl_opts}->{SSL_ca_file},
cert_file => $self->{ssl_opts}->{SSL_cert_file},
key_file => $self->{ssl_opts}->{SSL_key_file},
}
)
App-Dothe
view release on metacpan or search on metacpan
This file contains message digests of all files listed in MANIFEST,
signed via the Module::Signature module, version 0.79.
To verify the content in this distribution, first make sure you have
Module::Signature installed, then type:
% cpansign -v
It will check each file's integrity, as well as the signature's
App-DrivePlayer
view release on metacpan or search on metacpan
lib/App/DrivePlayer/SheetDB.pm view on Meta::CPAN
sub _open {
my ($self) = @_;
die "No spreadsheet_id configured\n" unless $self->spreadsheet_id;
# Use Drive API to verify the file exists and is not trashed before
# opening via Sheets API (which happily operates on trashed files).
my $drive = Google::RestApi::DriveApi3->new(api => $self->api);
my $meta = eval { $drive->file(id => $self->spreadsheet_id)->get(fields => 'id,trashed') };
if ($@) {
die "SHEET_NOT_FOUND: $@" if $@ =~ /404|not.?found/i;
App-Du-Analyze
view release on metacpan or search on metacpan
t/data/fc-solve-git-du-output.txt view on Meta::CPAN
8 ./fc-solve/site/wml/lib/jquery
316 ./fc-solve/site/wml/lib
8 ./fc-solve/site/wml/src/js-fc-solve/automated-tests
16 ./fc-solve/site/wml/src/js-fc-solve/text
36 ./fc-solve/site/wml/src/js-fc-solve
8 ./fc-solve/site/wml/src/verify-code
440 ./fc-solve/site/wml/src/downloads/dbm-fc-solver
444 ./fc-solve/site/wml/src/downloads
20 ./fc-solve/site/wml/src/pysol
4 ./fc-solve/site/wml/src/docs/distro
44 ./fc-solve/site/wml/src/docs
t/data/fc-solve-git-du-output.txt view on Meta::CPAN
42364 ./fc-solve/presets/soft-threads
308 ./fc-solve/presets/flares-based-scans-data
44208 ./fc-solve/presets
8 ./fc-solve/scripts/old
12 ./fc-solve/scripts/range-solving-of-deals
28 ./fc-solve/scripts/parallel-solve-and-verify-for-bakers-game
8 ./fc-solve/scripts/automatic-build-for-982-2fc-solving/kaz_tree
16 ./fc-solve/scripts/automatic-build-for-982-2fc-solving
172 ./fc-solve/scripts
36 ./fc-solve/rejects/Cmd-Line-Presets/Shlomif/FCS/CalcMetaScan
60 ./fc-solve/rejects/Cmd-Line-Presets/Shlomif/FCS
App-DubiousHTTP
view release on metacpan or search on metacpan
bin/dubious_http.pl view on Meta::CPAN
Setting up your own payload:
The default payload for evasion tests is the EICAR test virus which gets served
as ZIP file eicar.zip and if this gets not detected as plain TXT file eicar.txt.
To verify that the firewall does not block innocent files novirus.txt is used.
All of these payloads are builtin.
It is possible to setup own payload as following:
1. Reserve a directory for the payload files.
App-DuckPAN
view release on metacpan or search on metacpan
lib/App/DuckPAN/Web.pm view on Meta::CPAN
is => 'ro',
default => sub {
LWP::UserAgent->new(
agent => "Mozilla/5.0", #User Agent required for some API's (eg. Vimeo, IsItUp)
timeout => 5,
ssl_opts => { verify_hostname => 0 },
env_proxy => 1,
);
},
);
App-EC2Cssh
view release on metacpan or search on metacpan
lib/App/EC2Cssh.pm view on Meta::CPAN
}
sub _build_ec2{
my ($self) = @_;
# Hack so we never verify Amazon's host. Whilst still keeping HTTPS
IO::Socket::SSL::set_defaults( SSL_verify_callback => sub{ return 1; } );
my $ec2 = Net::Amazon::EC2->new({ %{ $self->config()->{ec2_config} || die "No ec2_config in config\n" } , ssl => 1 } );
return $ec2;
}
sub main{
App-Eduard
view release on metacpan or search on metacpan
lib/App/Eduard.pm view on Meta::CPAN
$msg = find_pgp_part $msg, $gpg
}
if ($gpg->is_signed($msg)) {
debug 'This mail looks signed';
my ($code, $keyid, $email) = $gpg->verify($msg);
return sign_error => (
message => stringify $gpg->{last_message}) if $code;
return sign => (
keyid => $keyid,
email => $email,
lib/App/Eduard.pm view on Meta::CPAN
} elsif ($status eq 'encrypt_error') {
say 'This message is encrypted but I was unable to decrypt it. GnuPG output: ', $params{message};
} elsif ($status eq 'sign') {
say 'This message is signed with key ', $params{keyid}, ' from ', $params{email};
} elsif ($status eq 'sign_error') {
say 'This message is signed but I was unable to verify the signature. GnuPG output: ', $params{message};
} elsif ($status eq 'plain') {
say 'This message is neither signed nor encrypted';
} elsif ($status eq 'error') {
say 'There was an error processing the message: ', $params{message};
}
App-ElasticSearch-Utilities
view release on metacpan or search on metacpan
lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN
$opts{SSL_cert_file} = $DEF{CERT} if $DEF{CERT};
$opts{SSL_key_file} = $DEF{KEY} if $DEF{KEY};
# Disable Certificate Verification
if ( $DEF{INSECURE} ) {
$opts{verify_hostname} = 0;
$opts{SSL_verify_mode} = 0x00;
}
return \%opts;
}
sub _get_es_version {
lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN
--host ElasticSearch host to connect to
--port HTTP port for your cluster
--proto Defaults to 'http', can also be 'https'
--http-username HTTP Basic Auth username
--password-exec Script to run to get the users password
--insecure Don't verify TLS certificates
--cacert Specify the TLS CA file
--capath Specify the directory with TLS CAs
--cert Specify the path to the client certificate
--key Specify the path to the client private key file
--noop Any operations other than GET are disabled, can be negated with --no-noop
lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN
By default, HTTP proxy environment variables are stripped. Use this option to keep your proxy environment variables
in tact.
=item B<insecure>
Don't verify TLS certificates
=item B<cacert>
Specify a file with the TLS CA certificates.
App-Env-Login
view release on metacpan or search on metacpan
inc/Module/Install/CPANfile.pm view on Meta::CPAN
if ($self->is_admin) {
$self->admin->include_one_dist("Module::CPANfile");
if (eval { require CPAN::Meta::Check; 1 }) {
my $prereqs = Module::CPANfile->load->prereqs;
my @err = CPAN::Meta::Check::verify_dependencies($prereqs, [qw/runtime build test develop/], 'requires');
for (@err) {
warn "Warning: $_\n";
}
} else {
warn "CPAN::Meta::Check is not installed. Skipping dependencies check for the author.\n";
App-Env
view release on metacpan or search on metacpan
is( App::Env->new( 'App1' )->env->{Site1_App1}, 1, 'import App1, id => default' );
is( App::Env->new( 'App1', { CacheID => 'foo' } )->env->{Site1_App1},
2, 'import App1, id => "foo"' );
# verify that the old one is still cached.
is( App::Env->new( 'App1' )->env->{Site1_App1}, 1, 're-import App1, id => default' );
# and now try for foo again
is( App::Env->new( 'App1', { CacheID => 'foo' } )->env->{Site1_App1},
2, 're-import App1, id => "foo"' );
App-EventStreamr
view release on metacpan or search on metacpan
share/status/app/lib/angular/angular-cookies.js view on Meta::CPAN
$browser.cookies(name, value);
updated = true;
}
}
//verify what was actually stored
if (updated){
updated = false;
browserCookies = $browser.cookies();
for (name in cookies) {
App-FargateStack
view release on metacpan or search on metacpan
lib/App/FargateStack.pm view on Meta::CPAN
my ( $cluster, $tasks ) = $self->common_args(qw(cluster tasks));
my $cluster_name = $cluster->{name};
$self->verify_service($service_name);
require Text::Wrap;
Text::Wrap->import('wrap');
{
lib/App/FargateStack.pm view on Meta::CPAN
my ( $config, $cluster, $dryrun ) = $self->common_args(qw(config cluster dryrun));
my $cluster_name = $cluster->{name};
$self->verify_service($task_name);
$self->check_task( $task_name, 'warn' );
$self->log_warn( 'remove-service: task [%s] will be deleted...%s', $task_name, $dryrun );
lib/App/FargateStack.pm view on Meta::CPAN
return $SUCCESS;
}
########################################################################
sub verify_service {
########################################################################
my ( $self, $service_name ) = @_;
my ( $cluster, $config ) = $self->common_args(qw(cluster config));
lib/App/FargateStack.pm view on Meta::CPAN
my ($cluster) = $self->common_args(qw(cluster));
my $cluster_name = $cluster->{name};
$self->verify_service($service_name);
my $ecs = $self->fetch_ecs;
my $task_definition_arn = $self->get_latest_task_definition($service_name);
lib/App/FargateStack.pm view on Meta::CPAN
my ( $config, $cluster ) = $self->common_args(qw(config cluster));
my $cluster_name = $cluster->{name};
$self->verify_service($task_name);
my $ecs = $self->get_ecs;
my $result = $ecs->update_service(
cluster_name => $cluster_name,
App-FastishCGI
view release on metacpan or search on metacpan
This file contains message digests of all files listed in MANIFEST,
signed via the Module::Signature module, version 0.68.
To verify the content in this distribution, first make sure you have
Module::Signature installed, then type:
% cpansign -v
It will check each file's integrity, as well as the signature's
( run in 0.958 second using v1.01-cache-2.11-cpan-600a1bdf6e4 )