Image

head

code

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

Staticish - make a singleton class with "static" method wrappers


=begin code

    use Staticish;

    class Foo is Static {
        has Str $.bar is rw;
    }

    Foo.bar = "There you go";
    say Foo.bar; # > "There you go";

=end code


This provides a mechanism whereby a class can be treated as a "singleton"
and all of its methods wrapped such that if they are called as "class"
or "static" methods they will actually be called on the single instance.
It does this by applying a role to the class itself which provides a
constructor "new()"  that will always return the same instance of the
object, and by applying a role to the classes Meta class which over-rides
the "add_method" method in order to wrap the programmer supplied methods
such that if the method is called on the type object (i.e. as a class
method) then the single instance will be obtained and the method will
be called with that as the invocant.


This might be useful for a class such as a configuration parser or
logger where a single set of parameters will be used globally within an
application and it doesn't make sense to pass a single object around.


There are no methods in this module, it is sufficient to use the module
in the scope that your class is declared, and then declare the class with
"is Static" as in the synopis above.  This may look like the introduction
of a base class but the "is" is over-ridden (it just made more sense than
the other trait introducing verbs to me.)



module Staticish:ver<0.0.8>:auth<github:jonathanstowe>:api<1.0> {
    role MetamodelX::StaticHOW {
        my %bypass = :new, :bless, :TWEAK, :BUILDALL, :BUILD, 'dispatch:<!>' => True;

        method _rw_wrapper($self: |c) is rw {
            my $new-self = $self;
            if not $new-self.defined {
                $new-self = $self.new;
            }
            callwith($new-self,|c);
        }

        method _ro_wrapper($self: |c) {
            my $new-self = $self;
            if not $new-self.defined {
                $new-self = $self.new;
            }
            callwith($new-self,|c);
        }


        method compose(Mu $obj) {
            callsame;
            for  $obj.^method_table.kv -> $name, $code {
                if not %bypass{$name}:exists {
                    my Bool $rw = so $code.rw;
                    # This is horrid but callwith needs to see the 'rw'
                    # when the wrapper is compiled it seems
                    my $wrapper = $rw ?? self.^find_method('_rw_wrapper') !! self.^find_method('_ro_wrapper');
                    $code.wrap($wrapper);
                }
            }
        }
    }

    role Singleton {
        my $instance;
        method new(|c) {
            if not $instance.defined {
                $instance = self.bless(|c);
            }
            $instance;
        }
    }

    multi sub trait_mod:<is>(Mu:U $doee, :$Static!) is export {
        $doee.HOW does MetamodelX::StaticHOW;
        $doee.^add_role(Singleton);
    }
}

# vim: expandtab shiftwidth=4 ft=raku


Staticish

=begin code :lang<raku>

use SSH::LibSSH::Tunnel;

=end code


SSH::LibSSH::Tunnel is a library (based on SSH::LibSSH) to simplify the setup of forwarding SSH tunnels.


Humberto Massa <humbertomassa@gmail.com>


This library is free software; you can redistribute it and/or modify it under either the Artistic License 2.0 or the LGPL v3.0, at your convenience.



use SSH::LibSSH;

constant LOCALHOST = '127.0.0.1';
has Str $.local-host is rw = LOCALHOST;
has Int $.local-port is rw = 0;
has Str $.tunnel-host is required;
has Int $.tunnel-port = 22;
has Str $.tunnel-user is required;
has Str $.remote-host is required;
has Int $.remote-port is required;
has IO() $.private-key-file is required;

method connect() {
  my Promise $tunnel-server .= new;
  my $remote-connection = await SSH::LibSSH.connect: host => $.tunnel-host, port => $.tunnel-port,
    user => $.tunnel-user, private-key => $.private-key-file;
  start {
    react {
      $tunnel-server.keep: do
        whenever IO::Socket::Async.listen($.local-host, $.local-port) -> IO::Socket::Async:D $connection {
          whenever $remote-connection.forward($.remote-host, $.remote-port, $.local-host, $.local-port) -> $channel {
            whenever $connection.Supply(:bin) {
              $channel.write: $_;
              LAST $channel.close
            }
            whenever $channel.Supply(:bin) {
              $connection.write: $_;
              LAST $connection.close
            }
            QUIT { $tunnel-server.close; .rethrow }
          }
        }
      whenever signal(SIGINT) {
        #yap "Shutting down tunnel to $remote-host:$remote-port at $local-port thru $host";
        $remote-connection.close;
        done
      }
    }
  }
  my $server = await $tunnel-server;
  $.local-host = await $server.socket-host;
  $.local-port = await $server.socket-port;
  self
}




Tunnel

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

NAME

SYNOPSIS

DESCRIPTION

AUTHOR

COPYRIGHT AND LICENSE

SSH::LibSSH::Tunnel v0.0.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation