view release on metacpan or  search on metacpan

lib/App/DiffDBSchemaUtils.pm  view on Meta::CPAN

    },
    username1 => {
        schema => 'str*',
        tags => ['category:db-connection'],
    },
    password1 => {
        schema => 'str*',
        tags => ['category:db-connection'],
    },
    dsn2 => {
        schema => 'str*',

lib/App/DiffDBSchemaUtils.pm  view on Meta::CPAN

    },
    username2 => {
        schema => 'str*',
        tags => ['category:db-connection'],
    },
    password2 => {
        schema => 'str*',
        tags => ['category:db-connection'],
    },
);

lib/App/DiffDBSchemaUtils.pm  view on Meta::CPAN

#    require DBIx::Connect::Any;
#
#    my %args = @_;
#
#    my $dbh = DBIx::Connect::Any->connect(
#        $args{dsn}, $args{username}, $args{password},
#        {RaiseError=>1});
#
#}

$SPEC{diff_db_schema} = {

lib/App/DiffDBSchemaUtils.pm  view on Meta::CPAN

    require DBIx::Connect::Any;

    my %args = @_;

    my $dbh1 = DBIx::Connect::Any->connect(
        $args{dsn1}, $args{username1}, $args{password1},
        {RaiseError=>1});
    my $dbh2 = DBIx::Connect::Any->connect(
        $args{dsn2}, $args{username2}, $args{password2},
        {RaiseError=>1});

    require DBIx::Diff::Schema;

    my $res = DBIx::Diff::Schema::diff_db_schema($dbh1, $dbh2);

lib/App/DiffDBSchemaUtils.pm  view on Meta::CPAN

=item * B<dsn1>* => I<str>

=item * B<dsn2>* => I<str>

=item * B<password1> => I<str>

=item * B<password2> => I<str>

=item * B<username1> => I<str>

=item * B<username2> => I<str>

lib/App/DiffDBSchemaUtils.pm  view on Meta::CPAN

=item * B<db2>* => I<str>

Name of the second MySQL database.

=item * B<password1> => I<str>

=item * B<password2> => I<str>

=item * B<username1> => I<str>

=item * B<username2> => I<str>

lib/App/DiffDBSchemaUtils.pm  view on Meta::CPAN

=item * B<db2>* => I<str>

Name of the second PostgreSQL database.

=item * B<password1> => I<str>

=item * B<password2> => I<str>

=item * B<username1> => I<str>

=item * B<username2> => I<str>

lib/App/DiffDBSchemaUtils.pm  view on Meta::CPAN

=item * B<db2>* => I<str>

Name of the second PostgreSQL database.

=item * B<password1> => I<str>

=item * B<password2> => I<str>

=item * B<username1> => I<str>

=item * B<username2> => I<str>

 view release on metacpan or  search on metacpan

script/dir2dist  view on Meta::CPAN

 [profile=production]
 username=bar
 pass=honey

When you specify C<--config-profile=dev>, C<username> will be set to C<foo> and
C<password> to C<beaver>. When you specify C<--config-profile=production>,
C<username> will be set to C<bar> and C<password> to C<honey>.


=item B<--no-config>, B<-C>

Do not use any configuration file.

 view release on metacpan or  search on metacpan

t/data/generate/pam-krb5/docknot.yaml  view on Meta::CPAN

blurb: |
  pam-krb5 is a Kerberos PAM module for either MIT Kerberos or Heimdal.  It
  supports ticket refreshing by screen savers, configurable authorization
  handling, authentication of non-local accounts for network services,
  password changing, and password expiration, as well as all the standard
  expected PAM features.  It works correctly with OpenSSH, even with
  ChallengeResponseAuthentication and PrivilegeSeparation enabled, and
  supports extensive configuration either by PAM options or in krb5.conf or
  both.  PKINIT is supported with recent versions of both MIT Kerberos and
  Heimdal and FAST is supported with recent MIT Kerberos.

description: |
  pam-krb5 provides a Kerberos PAM module that supports authentication, user
  ticket cache handling, simple authorization (via .k5login or checking
  Kerberos principals against local usernames), and password changing.  It can
  be configured through either options in the PAM configuration itself or
  through entries in the system krb5.conf file, and it tries to work around
  PAM implementation flaws in commonly-used PAM-enabled applications such as
  OpenSSH and xdm.  It supports both PKINIT and FAST to the extent that the
  underlying Kerberos libraries support these features.

t/data/generate/pam-krb5/docknot.yaml  view on Meta::CPAN

    against a Heimdal server, the test will be skipped; if you use the Heimdal
    library against an MIT server, the test suite may hang.

    Several `module/expired` tests are expected to fail with Heimdal 1.5 due
    to a bug in Heimdal with reauthenticating immediately after a
    library-mediated password change of an expired password.  This is fixed in
    later releases of Heimdal.

    To run the full test suite, Perl 5.10 or later is required.  The following
    additional Perl modules will be used if present:

t/data/generate/pam-krb5/docknot.yaml  view on Meta::CPAN

      Be sure to include the module in the session group as well as the auth
      group.  Without the session entry, the user's ticket cache will not be
      created properly for ssh logins (among possibly others).

      If your users should normally all use Kerberos passwords exclusively,
      putting something like:

      ```
          password sufficient pam_krb5.so minimum_uid=1000
          password required   pam_unix.so try_first_pass obscure md5
      ```

      in `/etc/pam.d/common-password` will change users' passwords in Kerberos
      by default and then only fall back on Unix if that doesn't work.  (You
      can make this tighter by using the more complex new-style PAM
      configuration.)  If you instead want to synchronize local and Kerberos
      passwords and change them both at the same time, you can do something
      like:

      ```
          password required   pam_unix.so obscure sha512
          password required   pam_krb5.so use_authtok minimum_uid=1000
      ```

      If you have multiple environments that you want to synchronize and you
      don't want password changes to continue if the Kerberos password change
      fails, use the `clear_on_fail` option.  For example:

      ```
          password required   pam_krb5.so clear_on_fail minimum_uid=1000
          password required   pam_unix.so use_authtok obscure sha512
          password required   pam_smbpass.so use_authtok
      ```

      In this case, if `pam_krb5` cannot change the password (due to password
      strength rules on the KDC, for example), it will clear the stored
      password (because of the `clear_on_fail` option), and since `pam_unix`
      and `pam_smbpass` are both configured with `use_authtok`, they will both
      fail.  `clear_on_fail` is not the default because it would interfere
      with the more common pattern of falling back to local passwords if the
      user doesn't exist in Kerberos.

      If you use a more complex configuration with the Linux PAM `[]` syntax
      for the session and account groups, note that `pam_krb5` returns a
      status of ignore, not success, if the user didn't log on with Kerberos.

t/data/generate/pam-krb5/docknot.yaml  view on Meta::CPAN

      On Red Hat systems, modify `/etc/pam.d/system-auth` instead, which
      contains all of the configuration for the different stacks.

      You can also use pam-krb5 only for specific services.  In that case,
      modify the files in `/etc/pam.d` for that particular service to use
      `pam_krb5.so` for authentication.  For services that are using passwords
      over TLS to authenticate users, you may want to use the `ignore_k5login`
      and `no_ccache` options to the authenticate module.  `.k5login`
      authorization is only meaningful for local accounts and ticket caches
      are usually (although not always) only useful for interactive sessions.

t/data/generate/pam-krb5/docknot.yaml  view on Meta::CPAN

      probably also need to add `retain_after_close` to the PAM configuration
      to avoid having the user's credentials deleted before they are logged
      in.

      The Solaris Kerberos library reportedly does not support prompting for a
      password change of an expired account during authentication.  Supporting
      password change for expired accounts on Solaris with native Kerberos may
      therefore require setting the `defer_pwchange` or `force_pwchange`
      option for selected login applications.  See the description and
      warnings about that option in the pam_krb5(5) man page.

      Some configuration options may be put in the `krb5.conf` file used by
      your Kerberos libraries (usually `/etc/krb5.conf` or
      `/usr/local/etc/krb5.conf`) instead or in addition to the PAM
      configuration.  See the man page for more details.

      The Kerberos library, via pam-krb5, will prompt the user to change their
      password if their password is expired, but when using OpenSSH, this will
      only work when `ChallengeResponseAuthentication` is enabled.  Unless
      this option is enabled, OpenSSH doesn't pass PAM messages to the user
      and can only respond to a simple password prompt.

      If you are using MIT Kerberos, be aware that users whose passwords are
      expired will not be prompted to change their password unless the KDC
      configuration for your realm in `[realms]` in `krb5.conf` contains a
      `master_kdc` setting or, if using DNS SRV records, you have a DNS entry
      for `_kerberos-master` as well as `_kerberos`.
  - title: Debugging
    body: |

t/data/generate/pam-krb5/docknot.yaml  view on Meta::CPAN

      return `PAM_IGNORE`, which tells the PAM library to proceed as if that
      module wasn't listed in the PAM configuration at all.
      `pam_authenticate`, however, returns failure in the ignored user case by
      default, since otherwise a configuration using `ignore_root` with
      pam-krb5 as the only PAM module would allow anyone to log in as root
      without a password.  There doesn't appear to be a case where returning
      `PAM_IGNORE` instead would improve the module's behavior, but if you
      know of a case, please let me know.

      By default, `pam_authenticate` intentionally does not follow the PAM
      standard for handling expired accounts and instead returns failure from
      `pam_authenticate` unless the Kerberos libraries are able to change the
      account password during authentication.  Too many applications either do
      not call `pam_acct_mgmt` or ignore its exit status.  The fully correct
      PAM behavior (returning success from `pam_authenticate` and
      `PAM_NEW_AUTHTOK_REQD` from `pam_acct_mgmt`) can be enabled with the
      `defer_pwchange` option.

t/data/generate/pam-krb5/docknot.yaml  view on Meta::CPAN

          pam_setcred
          pam_open_session
      ```

      During the first `pam_authenticate`, we can't obtain credentials and
      therefore a ticket cache since the password is expired.  But
      `pam_authenticate` isn't called again after `pam_chauthtok`, so
      `pam_chauthtok` has to create a ticket cache.  We however don't want it
      to do this for the normal password change (`passwd`) case.

      What we do is set a flag in our PAM data structure saying that we're
      processing an expired password, and `pam_chauthtok`, if it sees that
      flag, redoes the authentication with password prompting disabled after
      it finishes changing the password.

      Unfortunately, when handling password changes this way, `pam_chauthtok`
      will always have to prompt the user for their current password again
      even though they just typed it.  This is because the saved
      authentication tokens are cleared after `pam_authenticate` returns, for
      security reasons.  We could hack around this by saving the password in
      our PAM data structure, but this would let the application gain access
      to it (exactly what the clearing is intended to prevent) and breaks a
      PAM library guarantee.  We could also work around this by having
      `pam_authenticate` get the `kadmin/changepw` authenticator in the
      expired password case and store it for `pam_chauthtok`, but it doesn't
      seem worth the hassle.
  - title: History and Acknowledgements
    body: |
      Originally written by Frank Cusack <fcusack@fcusack.com>, with the
      following acknowledgement:

 view release on metacpan or  search on metacpan

config/CLI_Config.pm  view on Meta::CPAN

#     nick to use when we authenticate ourselves to the App::Dochazka::REST server
#     when this is set to '' or undef, App::Dochazka::CLI will prompt for it
set( 'DOCHAZKA_REST_LOGIN_NICK', undef );

# DOCHAZKA_REST_LOGIN_NICK
#     password to use when we authenticate ourselves to the App::Dochazka::REST server
#     when this is set to '' or undef, App::Dochazka::CLI will prompt for a password
#     WARNING: PUTTING YOUR PASSWORD HERE MAY BE CONVENIENT, BUT IS PROBABLY UNSAFE
set( 'DOCHAZKA_REST_LOGIN_PASSWORD', undef );

# MREST_CLI_COOKIE_JAR
#     default location of the cookie jar

 view release on metacpan or  search on metacpan

lib/App/Dochazka/Common.pm  view on Meta::CPAN

All four of these, plus the C<eid> field, have C<UNIQUE> constraints defined at
the database level, meaning that duplicate entries are not permitted. However,
of the four, only C<nick> is required.

Depending on how authentication is set up, employee passwords may also be
stored in this table, using the C<passhash> and C<salt> fields.

For details, see L<App::Dochazka::REST::Model::Employee>.

 view release on metacpan or  search on metacpan

config/REST_Config.pm  view on Meta::CPAN

#     N.B. 1 administrators can edit all fields, and passerbies can't edit any
#     N.B. 2 if LDAP authentication and LDAP import/sync are being used, it may not 
#            make sense for employees to edit *any* of the fields
#     N.B. 3 this site param affects the functioning of the "POST employee/self" and "POST employee/current" resources
set( 'DOCHAZKA_PROFILE_EDITABLE_FIELDS', {
    'inactive' => [ 'password' ],
    'active' => [ 'password' ],
});

# DOCHAZKA_INTERVAL_SELECT_LIMIT
#     upper limit on number of intervals fetched (for sanity, to avoid
#     overly huge result sets)

 view release on metacpan or  search on metacpan

lib/App/Dochazka/WWW/Dispatch.pm  view on Meta::CPAN

    $log->debug( "Entering " . __PACKAGE__ . "::validate_user_credentials()" );

    my $r = $self->request;
    my $session = $self->session;
    my $nick = $body->{'nam'};
    my $password = $body->{'pwd'};
    my $standalone = $meta->META_WWW_STANDALONE_MODE;

    $log->debug( "Employee $nick login attempt" );
    $log->debug( "DOCHAZKA_WWW_BACKEND_URI is " .  $site->DOCHAZKA_WWW_BACKEND_URI );

    my ( $code, $message, $body_json );
    my $rr = $self->rest_req( {
        server => $site->DOCHAZKA_WWW_BACKEND_URI,
        nick => $nick,
        password => $password,
        path => 'employee/self/full',
    } );
    $code = $rr->{'hr'}->code;
    $message = $rr->{'hr'}->message;
    $body_json = $rr->{'body'};

 view release on metacpan or  search on metacpan

lib/App/DoubleUp.pm  view on Meta::CPAN

    my $self = shift;
    return @{$self->{config}{credentials}};
}

sub connect_to_db {
    my ($self, $dsn, $user, $password) = @_;
    return DBI->connect($dsn, $user, $password, { RaiseError => 1, PrintError => 0 }) || croak "Error while connecting to '$dsn'";
}

sub process_querys_for_one_db {
    my ($self, $db, $querys) = @_;

 view release on metacpan or  search on metacpan

script/foremost-download  view on Meta::CPAN

 [profile=production]
 username=bar
 pass=honey

When you specify C<--config-profile=dev>, C<username> will be set to C<foo> and
C<password> to C<beaver>. When you specify C<--config-profile=production>,
C<username> will be set to C<bar> and C<password> to C<honey>.


=item B<--no-config>, B<-C>

Do not use any configuration file.

 view release on metacpan or  search on metacpan

README.md  view on Meta::CPAN

#### Logging into the VM

Once you have installed the virtual machine you should be able to start up the VM and login with the following credentials:
- **username** : `vagrant`
- **password** : `duckduckhack`


#### Cloning the repository on the VM

**The DuckPAN client has already been installed for you.** To use it, you must 1st clone your instant answer git repository.

 view release on metacpan or  search on metacpan

script/list-dist-deps  view on Meta::CPAN

 [profile=production]
 username=bar
 pass=honey

When you specify C<--config-profile=dev>, C<username> will be set to C<foo> and
C<password> to C<beaver>. When you specify C<--config-profile=production>,
C<username> will be set to C<bar> and C<password> to C<honey>.


=item B<--no-config>, B<-C>

Do not use any configuration file.

 view release on metacpan or  search on metacpan

lib/App/ElasticSearch/Utilities.pm  view on Meta::CPAN

            base|index-basename=s
            days=i
            noop!
            proto=s
            http-username=s
            password-exec=s
            master-only|M
            insecure
            capath=s
            cacert=s
            cert=s

lib/App/ElasticSearch/Utilities.pm  view on Meta::CPAN

                     : exists $_GLOBALS{days}  ? $_GLOBALS{days} : 1,
        # HTTP Basic Authentication
        USERNAME    => exists $opts->{'http-username'}    ? $opts->{'http-username'}
                     : exists $_GLOBALS{'http-username'}  ? $_GLOBALS{'http-username'}
                     : $ENV{USER},
        PASSEXEC    => exists $opts->{'password-exec'}   ? $opts->{'password-exec'}
                     : exists $_GLOBALS{'password-exec'} ? $_GLOBALS{'password-exec'}
                     : undef,
        # TLS Options
        INSECURE    => exists $opts->{insecure} ? 1
                    :  exists $_GLOBALS{insecure} ? $_GLOBALS{insecure}
                    :  0,

lib/App/ElasticSearch/Utilities.pm  view on Meta::CPAN

    es_utils_initialize() unless keys %DEF;

    $host ||= $DEF{HOST};

    # Return the results if we've done this already
    return @{ $_auth_cache{$host} }{qw(username password)}
        if exists $_auth_cache{$host};

    # Set the cached element
    my %auth = ();

lib/App/ElasticSearch/Utilities.pm  view on Meta::CPAN

    my $netrc = Net::Netrc->lookup($host);
    if( $DEF{HOST} eq $host ) {
        %auth = map { lc($_) => $DEF{$_} } qw(USERNAME);
    }
    my %meta = ();
    foreach my $k (qw( http-username password-exec )) {
        foreach my $name ( $DEF{INDEX}, $DEF{BASE} ) {
            next unless $name;
            if( my $v = es_local_index_meta($k, $name) ) {
                $meta{$k} = $v;
                last;

lib/App/ElasticSearch/Utilities.pm  view on Meta::CPAN

    $auth{username} ||= $meta{'http-username'} ? $meta{'http-username'}
                      : defined $DEF{USERNAME} ? $DEF{USERNAME}
                      : defined $netrc         ? $netrc->login
                      : $ENV{USER};

    # Prompt for the password
    $auth{password} ||= defined $netrc ? $netrc->password
                      : (es_pass_exec($host,$auth{username},$meta{'password-exec'})
                            || prompt(sprintf "Password for '%s' at '%s': ", $auth{username}, $host)
                        );

    # Store
    $_auth_cache{$host} = \%auth;
    return @auth{qw(username password)};
}


sub es_pass_exec {
    my ($host,$username,$exec) = @_;

lib/App/ElasticSearch/Utilities.pm  view on Meta::CPAN

    # Simplest case we can't run
    $exec ||= $DEF{PASSEXEC};
    return unless length $exec && -x $exec;

    my(@out,@err);
    # Run the password command captue out, error and RC
    run3 [ $exec, $host, $username ], \undef, \@out, \@err;
    my $rc = $?;

    # Record the error
    if( @err or $rc != 0 ) {

lib/App/ElasticSearch/Utilities.pm  view on Meta::CPAN

        GET => sprintf "%s://%s:%d",
                    $conn->proto, $conn->host, $conn->port
    );
    # Check if we're doing auth
    my @auth = $DEF{PASSEXEC} ? es_basic_auth($conn->host) : ();
    # Add authentication if we get a password
    $req->authorization_basic( @auth ) if @auth;

    # Retry with TLS and/or Auth
    my %try = map { $_ => 1 } qw( tls auth );
    my $resp;

lib/App/ElasticSearch/Utilities.pm  view on Meta::CPAN

        }
        elsif( $resp->code == 401 ) {
            # Retry with credentials
            last unless $try{auth};
            delete $try{auth};
            warn "Authorization required, try setting 'password-exec: /home/user/bin/get-password.sh` in ~/.es-utils.yaml'"
                unless $DEF{PASSEXEC};
            $req->authorization_basic( es_basic_auth($conn->host) );
        }
        else {
            warn "Failed getting version";

lib/App/ElasticSearch/Utilities.pm  view on Meta::CPAN

        ssl_opts => _get_ssl_opts,
    );
    # Only authenticate over TLS
    if( $DEF{PROTO} eq 'https' ) {
        $conn{username} = $DEF{USERNAME};
        $conn{password} = es_pass_exec(@DEF{qw(HOST USERNAME)}) if $DEF{PASSEXEC};
    }

    # If we're overriding, return a unique handle
    if(defined $override_servers) {
        my @overrides = is_arrayref($override_servers) ? @$override_servers : $override_servers;

lib/App/ElasticSearch/Utilities.pm  view on Meta::CPAN

Grab the value of the global value from the es-utils.yaml files.

=head2 es_basic_auth($host)

Get the user/password combination for this host.  This is called from LWP::UserAgent if
it recieves a 401, so the auth condition must be satisfied.

Returns the username and password as a list.

=head2 es_pass_exec(host, username)

Called from es_basic_auth to exec a program, capture the password
and return it to the caller.  This allows the use of password vaults
and keychains.

=head2 es_pattern

Returns a hashref of the pattern filter used to get the indexes

lib/App/ElasticSearch/Utilities.pm  view on Meta::CPAN

    --local         Use localhost as the elasticsearch host
    --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

lib/App/ElasticSearch/Utilities.pm  view on Meta::CPAN

    host: esproxy.example.com
    port: 80
    timeout: 10
    proto: https
    http-username: bob
    password-exec: /home/bob/bin/get-es-passwd.sh

=head1 CONNECTION ARGUMENTS

Arguments for establishing a connection with the cluster.  Unless specified otherwise, these options
can all be set in the globals file.

lib/App/ElasticSearch/Utilities.pm  view on Meta::CPAN

If HTTP Basic Authentication is required, use this username.

See also the L<HTTP Basic Authentication> section for more details

=item B<password-exec>

If HTTP Basic Authentication is required, run this command, passing the arguments:

    <command_to_run> <es_host> <es_username>

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.

lib/App/ElasticSearch/Utilities.pm  view on Meta::CPAN

    CLI::Helpers prompt()

Once the username has been resolved, the following mechanisms are tried in order:

    Netrc element matching the hostname of the request
    Password executable defined by --password-exec
    'password-exec' in /etc/es-utils.yml, ~/.es-utils.yml
    CLI::Helpers prompt()

=head2 Password Exec

It is B<BAD> practice to specify passwords as a command line argument, or store it in a plaintext
file.  There are cases where this may be necessary, but it is not recommended.  The best method for securing  your
password is to use the B<password-exec> option.

This option must point to an executable script.  That script will be passed two arguments, the hostname and the username
for the request.  It expects the password printed to STDOUT as the last line of output.  Here's an example password-exec setup
using Apple Keychain:

    #!/bin/sh

    HOSTNAME=$1;
    USERNAME=$2;

    /usr/bin/security find-generic-password -w -a "$USERNAME" -s "$HOSTNAME"

If we save this to "$HOME/bin/get-passwd.sh" we can execute a script
like this:

    $ es-search.pl --http-username bob --password-exec $HOME/bin/get-passwd.sh \
                    --base secure-data --fields

Though it's probably best to set this in your ~/.es-utils.yml file:

    ---
    host: secured-cluster.example.org
    port: 443
    proto: https
    http-username: bob
    password-exec: /home/bob/bin/get-passwd.sh

=head3 CLI::Helpers and Password Prompting

If all the fails to yield a password, the last resort is to use CLI::Helpers::prompt() to ask the user for their
password.  If the user is using version 1.1 or higher of CLI::Helpers, this call will turn off echo and readline magic
for the password prompt.

=head1 INSTALL

B<This library attempts to provide scripts compatible with version 0.19 through 1.1 of ElasticSearch>.

 view release on metacpan or  search on metacpan

LICENSE  view on Meta::CPAN

protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this

 view release on metacpan or  search on metacpan

LICENSE  view on Meta::CPAN

protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this

 view release on metacpan or  search on metacpan

lib/App/Environ/Mojo/Pg.pm  view on Meta::CPAN

  ## Non standart schema workaround
  ## For URI objects that do not belong to one of these, you can only use the common and generic methods.
  $url->scheme('https');

  $url->userinfo("$conf->{user}:$conf->{password}");
  $url->host( $conf->{host} );
  $url->port( $conf->{port} );
  $url->path( $conf->{dbname} );
  $url->query_form( %{ $conf->{options} } );

 view release on metacpan or  search on metacpan

example/pg.yml  view on Meta::CPAN

  connectors:
    main:
      host: 'db.example.com'
      port: 5432
      user: 'main'
      password: 'main'
      dbname: 'postgres'
      options:
        PrintWarn: 0
        PrintError: 0
        RaiseError: 1

 view release on metacpan or  search on metacpan

bin/station-mgr.pl  view on Meta::CPAN

                    host      => $self->{config}{mixer}{host},
                    port      => $self->{config}{mixer}{port},
                    id        => $id,
                    shost     => $self->{config}{stream}{host},
                    sport     => $self->{config}{stream}{port},
                    spassword => $self->{config}{stream}{password},
                    stream    => $self->{config}{stream}{stream},
                  );

  $command =~ s/\$(\w+)/$cmd_vars{$1}/g;

bin/station-mgr.pl  view on Meta::CPAN

  "run" : "0",
  "stream" :
    {
      "host" : "",
      "port" : "",
      "password" : "",
      "stream" : ""
    }
}
CONFIG

bin/station-mgr.pl  view on Meta::CPAN

          'commands' => {
                          'alsa' => 'dvsource-alsa -h $host -p $port hw:$device',
                          'dv' => 'dvsource-firewire -h $host -p $port -c $device',
                          'record' => 'dvsink-files $device',
                          'v4l' => 'ffmpeg -f video4linux2 -s vga -r 25 -i $device -target pal-dv - | dvsource-file /dev/stdin -h $host -p $port',
                          'stream' => 'dvsink-command -- ffmpeg2theora - -f dv -F 25:2 --speedlevel 0 -v 4  --optimize -V 420 --soft-target -a 4 -c 1 -H 44100 -o - | oggfwd $host $port 8000 $password /$stream',
                          'file' => 'dvsource-file -l $device',
                          'dvswitch' => 'dvswitch -h 0.0.0.0 -p $port'
                        },
          'config' => {
                        'roles' => [

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

    - Redo the variables used in the Perl scripts for readability, including by
      separating the words in the variables by underscores.
    - Corrected an instance of a duped variable in bin/nl2ftndb help message.

0.08    Sat Aug 21 20:03 2010
    The default DBI user and password parameters for an SQLite database
    is an empty string;  change the default codeing for those in the bin/*
    scripts.

0.07    Sat Aug 21 18:19 2010
    - Correct script name in Makefile.PL from net2file to listftndb.

 view release on metacpan or  search on metacpan

lib/App/FTPThis.pm  view on Meta::CPAN

        "$dir/conf",
        join(
            "",
            "root directory: $self->{root}\n",
            "allow anonymous: 1\n",
            "anonymous password check: none\n",
            "anonymous password enforce: 0\n",
            "home directory: $self->{root}\n",
            "limit memory: -1\n",
            "limit nr processes: -1\n",
            "limit nr files: -1\n",
        ),

 view release on metacpan or  search on metacpan

lib/App/FargateStack/Builder/Secrets.pm  view on Meta::CPAN

    else {
      ( $secret, $secret_arn ) = %{$secret};
      ( $path, $env_name ) = split /:/xsm, $secret;
    }

    log_die( $self, 'secret value must be path:env-name, not %s, example: /mysql/password:DB_PASSWORD', $secret )
      if !$env_name || !$path;

    push @secrets, { name => $env_name, valueFrom => $secret_arn };
  }

 view release on metacpan or  search on metacpan

script/reencode-video-with-libx264  view on Meta::CPAN

 [profile=production]
 username=bar
 pass=honey

When you specify C<--config-profile=dev>, C<username> will be set to C<foo> and
C<password> to C<beaver>. When you specify C<--config-profile=production>,
C<username> will be set to C<bar> and C<password> to C<honey>.


=item B<--no-config>, B<-C>

Do not use any configuration file.

 view release on metacpan or  search on metacpan

lib/App/Filite/Client.pm  view on Meta::CPAN

use JSON::PP qw( encode_json decode_json );
use MIME::Base64 qw( encode_base64 );
use Path::Tiny qw( path );

use Class::Tiny {
	password   => sub { croak "Missing option: password" },
	server     => sub { croak "Missing option: server" },
	useragent  => sub { shift->_build_useragent },
	errors     => sub { 0 },
};

lib/App/Filite/Client.pm  view on Meta::CPAN

	return $self;
}

sub _build_useragent {
	my ( $self ) = ( shift );
	my $auth = encode_base64( sprintf( 'admin:%s', $self->password ) );
	chomp $auth;
	return HTTP::Tiny->new(
		agent => sprintf( '%s/%s ', __PACKAGE__, $VERSION ),
		default_headers => { 'Authorization' => "Basic $auth" },
	);

lib/App/Filite/Client.pm  view on Meta::CPAN

=item C<< server >> B<< Str >>

The filite server to share things via. This will typically be a URL
like "https://example.com/" or "http://example.net:8080".

=item C<< password >> B<< Str >>

Filite is a single user system so has a password but no username.

=item C<< useragent >> B<< Object >>

Can be set to a custom L<HTTP::Tiny> instance. Cannot be specified in
the config file.

 view release on metacpan or  search on metacpan

script/restart-firefox  view on Meta::CPAN

 [profile=production]
 username=bar
 pass=honey

When you specify C<--config-profile=dev>, C<username> will be set to C<foo> and
C<password> to C<beaver>. When you specify C<--config-profile=production>,
C<username> will be set to C<bar> and C<password> to C<honey>.


=item B<--no-config>, B<-C>

Do not use any configuration file.

 view release on metacpan or  search on metacpan

lib/App/Foca/Server.pm  view on Meta::CPAN

Well, lets suppose you have a log parser on all your servers and you are in
need to parse all of them, the common way would be to ssh to each host (can
be as simple as ssh'ing to each host or using a multiplex tool) and execute
your parser, but what if your SSH keys or the keys of a user are not there?
It will be a heck of pain to enter your password hundred of times or lets
imagine you want to parse your logs via some automation (like doing it from
an IRC bot or tied to your monitoring solution).. then the problem comes
more complex with SSH and private keys. With Foca you don't need to worry
about those things, the command will get executed and the output will be
returned as a HTTP response.

 view release on metacpan or  search on metacpan

lib/App/Followme/UploadFtp.pm  view on Meta::CPAN

#----------------------------------------------------------------------
# Open the connection to the remote site

sub open {
    my ($self, $user, $password) = @_;

    # Open the ftp connection

    my $ftp = Net::FTP->new($self->{ftp_url}, Debug => $self->{ftp_debug})
        or die "Cannot connect to $self->{ftp_url}: $@";

    $ftp->login($user, $password) or die "Cannot login ", $ftp->message;

    $ftp->cwd($self->{remote_directory})
        or die "Cannot change remote directory ", $ftp->message;

    $ftp->binary();

lib/App/Followme/UploadFtp.pm  view on Meta::CPAN

App::Followme::UploadFtp - Upload files using ftp

=head1 SYNOPSIS

    my $ftp = App::Followme::UploadNone->new(\%configuration);
    $ftp->open($user, $password);
    $ftp->add_directory($dir);
    $ftp->add_file($local_filename, $remote_filename);
    $ftp->delete_file($filename);
    $ftp->delete_dir($dir);
    $ftp->close();

lib/App/Followme/UploadFtp.pm  view on Meta::CPAN

=back

=head1 CONFIGURATION

The follow parameters are used from the configuration. In addition, the package
will prompt for and save the user name and password.

=over 4

=item ftp_debug

 view release on metacpan or  search on metacpan

config.pl  view on Meta::CPAN

# Channels to join on OFTC
@oftc_channels = ();

# Password to identify to NickServ with
$oftc_nickserv_password = 'asd';

# BitlBee
# =======

# Comment this out to disable the BitlBee plugin

config.pl  view on Meta::CPAN

$bitlbee_server = 'localhost';

# BitlBee server port
$bitlbee_port = 6667;

# BitlBee server password
$bitlbee_password = 'parola';

# Common
# ======

# Directory to store state in

 view release on metacpan or  search on metacpan

examples/eg-sql.pl  view on Meta::CPAN

	# Set up database access
	$app->sql(
			'database'	=> $opts{'database'},
			'table'		=> $opts{'table'},
			'user'		=> $opts{'user'},
			'password'	=> $opts{'password'},
			
			# Option to do some Sql debugging by tracing transactions to a file
			'trace'		=> $opts{'debug'} ? 4 : 0,
			'trace_file'=> 'logsql.log',
			'debug' => $opts{'debug'},

examples/eg-sql.pl  view on Meta::CPAN

-user=s User

Your MySql user

-password=s	Pass

Your MySql password


__#=============================================================================================================================
__DATA__ listings2.sql

 view release on metacpan or  search on metacpan

lib/App/GHPT/WorkSubmitter/Role/Question.pm  view on Meta::CPAN

    package App::GHPT::WorkSubitter::Question::WarnAboutPasswordFile;
    use App::GHPT::Wrapper::OurMoose;
    with 'App::GHPT::WorkSubmitter::Role::Question';

    sub ask($self) {
        # skip the question unless there's a password file
        return unless $self->changed_files->changed_files_match(qr/password/);

        # ask the user if that's okay
        return $self->ask_question(<<'ENDOFTEXT',"I'm okay with the risk");
    You've committed a file with a name matching 'password'.  Are you nuts?
    ENDOFTEXT
    }

    __PACKAGE__->meta->make_immutable;
    1;

 view release on metacpan or  search on metacpan

LICENSE  view on Meta::CPAN

protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this

 view release on metacpan or  search on metacpan

LICENSE  view on Meta::CPAN

protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this