Free zshare gorillarms group software for linux

TAO project is a standards-compliant, real-time implementation of CORBA that provides efficient, predictable, and scalable quality of service (QoS) end-to-end.

Unlike conventional implementations of CORBA, which are inefficient, unpredictable, non-scalable, and often non-portable, TAO applies the best software practices and patterns to automate the delivery of high-performance and real-time QoS to distributed applications.

Over the past decade, my research group has worked with many collaborators on large-scale distributed application R&D projects in diverse domains, including command and control systems, telecom, datacom, medical engineering, distributed interactive simulations, and financial services. Regardless of the domain and application requirements, weve found that software developers wrestle with the same core infrastructure challenges. Key challenges focus on OS platform portability, connection management and service initialization, event demultiplexing and event handler dispatching, multi-threading and synchronization, fault detection and fault tolerance, and various quality-of-service (QoS) issues, such as controlling latency, throughput, and jitter end-to-end.

Unfortunately, its very costly, time consuming, and error-prone for researchers and developers companies to independently rediscover and reinvent ad hoc solutions to these core distributed application software development challenges. Fortunately, we have identified a relatively concise set of patterns and framework components that can be applied systematically to eliminate many tedious, error-prone, and non-portable aspects of developing and maintaining distributed applications.

A decade of intense R&D on these topics has yielded ACE, which is an object-oriented framework that implements many core patterns for concurrent communication software. We have applied the patterns and components in the ACE framework to develop The ACE ORB (TAO), which is our standards-based, CORBA middleware framework that allows clients to invoke operations on distributed objects without concern for object location, programming language, OS platform, communication protocols and interconnects, and hardware. TAO is designed using the best software practices and patterns that we have discovered in our work on ACE in order to automate the delivery of high-performance and real-time QoS to distributed applications.

Google::Adwords::AdGroupRequest is a Google Adwords AdGroupRequest Object.

METHODS

Mutators (read/write)

* id - The id of the ad group to be estimated. All keywords in the ad group will be estimated. Optional - if omitted indicates a new ad group.
* keywordRequests - The keywords to be estimated. This list must contain at least one Google::Adwords::KeywordRequest object.
* maxCpc - The bid for this ad group in micros.

Async::Group is a Perl class to deal with simultaneous asynchronous calls.

SYNOPSIS

use Async::Group ;
use strict ;

sub sub1
{
print "Dummy subroutine n";
my $dummy = shift ;
my $cb = shift ;

&$cb(1);
}

sub allDone
{
print "All done, result is ", shift ,"n" ;
}
my $a = Async::Group->new(name => aTest, test => 1) ;

$a->run(set => [ sub {⊂1( callback => sub {$a->callDone(@_)} )},
sub {⊂1( callback => sub {$a->callDone(@_)} )} ],
callback => &allDone
)

# or another way which avoids the clumsy nested subs
my $cb = $a->getCbRef();
$a->run(set => [ sub {⊂1( callback => $cb)},
sub {⊄1( callback => $cb )} ],
callback => &allDone
)

If you sometimes have to launch several asynchronous calls in parrallel and want to call one call-back function when all these calls are finished, this module may be for you.

Async::Group is a class which enables you to call several asynchronous routines. Each routine may have their own callback. When all the routine are over (i.e. all their callback were called), Async::Group will call the global callback given by the user.

Note that one Async::Group objects must be created for each group of parrallel calls. This object may be destroyed (or will vanish itself) once the global callback is called.

Note also that Async::Group does not perform any fork or other system calls. It just run the passed subroutines and keep count of the call-back functions called by the aforementionned subroutines. When all these subs are finished, it calls another call-back (passed by the user) to perform whatever function required by the user.

Using fork or threads or whatever is left to the user.

WWW::Google::Groups is a Perl module for Google Groups Agent.

BROWSING

use WWW::Google::Groups;

$agent = new WWW::Google::Groups
(
server => groups.google.com,
proxy => my.proxy.server:port,
);


$group = $agent->select_group(comp.lang.perl.misc);

$group->starting_thread(0); # Set the first thread to fetch
# Default starting thread is 0

while( $thread = $group->next_thread() ){
while( $article = $thread->next_article() ){

# the returned $article is an Email::Simple object
# See Email::Simple for its methods

print join q/ /, $thread->title, header(From).>, $/;
}
}
If you push raw to the argument stack of $thread->next_article(), it will return the raw format of messages.
while( $thread = $group->next_thread() ){
while( $article = $thread->next_article(raw) ){
print $article;
}
}
Even, you can use this more powerful method. It will try to mirror the whole newsgroup and save the messages to a Unix mbox.
$agent->save2mbox(
group => comp.lang.perl.misc,
starting_thread => 0,
max_article_count => 10000,
max_thread_count => 1000,
target_mbox => perl.misc.mbox,
);

WWW::Yahoo::Groups is an automated access to Yahoo! Groups archives.

SYNOPSIS

my $y = WWW::Yahoo::Groups->new();
$y->login( $user => $pass );
$y->list( Jade_Pagoda );
my $email = $y->fetch_message( 2345 );

# Error catching
my $email = eval { $y->fetch_message( 93848 ) };
if ( $@ and ref $@ and $@->isa(X::WWW::Yahoo::Groups) )
{
warn "Problem: ".$@->error;
}

WWW::Yahoo::Groups retrieves messages from the archive of Yahoo Groups. It provides a simple OO interface to logging in and retrieving said messages which you may then do with as you will.

Things it does

Handles access to restricted archives. It lets you login.
Handles the intermittent advertisements. It notes that it got one and progresses straight to the message.
Handle adult confirmation requests. It just goes straight on.
Handles attachments. We get the source which happens to be the raw stuff.
Sanity checking. Could be improved, but it will generally barf if it doesnt understand something.
Header restoration. Ive found that some groups archives have unusually corrupted headers. Evidently it would be beneficial to restore these headers. As far as I can tell, it comes from not being a moderator on the lists in question.

USAGE

Try to be a well behaved bot and sleep() for a few seconds (at least) after doing things. Its considered polite. Theres an autosleep method that should be useful for this. Recently, this has been set to a default of 1 second. Feel free to tweak if necessary.

If youre used to seeing munged email addresses when you view the message archive (i.e. youre not a moderator or owner of the group) then youll be pleased to know that WWW::Yahoo::Groups can demunge those email addresses.

All exceptions are subclasses of X::WWW::Yahoo::Groups, itself a subclass of Exception::Class. See WWW::Yahoo::Groups::Errors for details.

easy emailsManager (eEM) is a Web-based multi-user application for managing email.
easy emailsManager can manage multiple email accounts with different protocols (IMAP, POP3, NNTP) and share selected email with other users (of your own group, for example).
Main features:
- User, Group and Permission Management
- Emails Management
- German and English
- Editable Navigation tree
- Mandators (experimental)
- Extensible by plugins (experimental)