src/Utilities/CVSmodule.pm

=head1 NAME

Utilities::CVSmodule - A wrapper around CVS.

=head1 SYNOPSIS

        my $obj = Utilities::CVSmodule->new();

=head1 DESCRIPTION

Configure the CVSmodule object to access a CVS repository and then
invokecvs() commands as required.

=head1 METHODS

=over

=item C<new()>

A new cvs modules object.

=item C<set_base(base)>

Set a base from which to read (i.e server name/path).

=item C<set_auth(type)>

Set authentication method e.g pserver, kserver, ext etc.

=item C<set_user(username)>

Set a username for authentication if required.

=item C<set_passbase(file)>

Override the default CVS_PASSFILE for pserver client.

=item C<set_passkey(encrypted)>

For pserver method - set a password (encrypted).

=item C<invokecvs(@cmds)>

Invoke a cvs command supplied in @cmds.

=item C<repository()>

Return a string to indicate the repository.

=cut

=back

=head1 AUTHOR

Originally written by Christopher Williams.

=head1 MAINTAINER

Shaun ASHBY L<mailTo:Shaun.Ashby@cern.ch>

=cut

package Utilities::CVSmodule;
require Exporter;
use Utilities::AddDir;
require 5.004;
@ISA= qw(Exporter);

sub new {
        my $class=shift;
        my $self={};
        bless $self, $class;
        $self->{myenv}={};
        $self->{cvs}='cvs';
        # Reset All variables
        $self->{auth}="";
        $self->{passkey}="";
        $self->{user}="";
        $self->{base}="";
        $self->set_passbase("/tmp/".$>."CVSmodule/.cvspass");
        return $self;
}

sub set_passbase {
        my $self=shift;
        my $file=shift;

        my $dir;
        ($dir=$file)=~s/(.*)\/.*/$1/;
        AddDir::adddir($dir);
        $self->{passbase}=$file;
        $self->env("CVS_PASSFILE", $file);
}

sub set_passkey {
        use Utilities::SCRAMUtils;
        $self=shift;
        $self->{passkey}=shift;
        my $file=$self->{passbase};
        SCRAMUtils::updatelookup($file,
                $self->{cvsroot}." ", $self->{passkey});
}

sub set_base {
        $self=shift;
        $self->{base}=shift;
        $self->_updatecvsroot();
}

sub get_base {
}

sub set_user {
        $self=shift;
        $self->{user}=shift;
        if ( $self->{user} ne "" ) {
           $self->{user}= $self->{user}.'@';
        }
        $self->_updatecvsroot();
}
sub set_auth {
        $self=shift;
        $self->{auth}=shift;
        $self->{auth}=~s/^\:*(.*)\:*/\:$1\:/;
        
        $self->_updatecvsroot();
}

sub env {
        $self=shift;
        my $name=shift;
        $self->{myenv}{$name}=shift;
}

sub invokecvs {
        $self=shift;
        @cmds=@_;
        # make sure weve got the right environment
        foreach $key ( %{$self->{myenv}} ) {
          $ENV{$key}=$self->{myenv}{$key};
        }
        # now perform the cvs command
        return ( system( "$self->{cvs}" ,"-Q", "-d", "$self->{cvsroot}", @cmds ));
}

sub _updatecvsroot {
        my $self=shift;
        $self->{cvsroot}=$self->{auth}.$self->{user}.$self->{base};
}

sub cvsroot {
        my $self=shift;
        return $self->{cvsroot};
}

sub repository {
        my $self=shift;
        return $self->{base};
}
Revision:	1.9
Committed:	Wed Aug 10 17:27:32 2005 UTC (19 years, 9 months ago) by sashby
Content type:	text/plain
Branch:	MAIN
Changes since 1.8:	+62 -17 lines
Log Message:	Starting to add POD documentation.
#	User	Rev	Content
1	sashby	1.9	=head1 NAME
2
3			Utilities::CVSmodule - A wrapper around CVS.
4
5			=head1 SYNOPSIS
6
7			my $obj = Utilities::CVSmodule->new();
8
9			=head1 DESCRIPTION
10
11			Configure the CVSmodule object to access a CVS repository and then
12			invokecvs() commands as required.
13
14			=head1 METHODS
15
16			=over
17
18			=item C<new()>
19
20			A new cvs modules object.
21
22			=item C<set_base(base)>
23
24			Set a base from which to read (i.e server name/path).
25
26			=item C<set_auth(type)>
27
28			Set authentication method e.g pserver, kserver, ext etc.
29
30			=item C<set_user(username)>
31
32			Set a username for authentication if required.
33
34			=item C<set_passbase(file)>
35
36			Override the default CVS_PASSFILE for pserver client.
37
38			=item C<set_passkey(encrypted)>
39
40			For pserver method - set a password (encrypted).
41
42			=item C<invokecvs(@cmds)>
43
44			Invoke a cvs command supplied in @cmds.
45
46			=item C<repository()>
47
48			Return a string to indicate the repository.
49
50			=cut
51
52			=back
53
54			=head1 AUTHOR
55
56			Originally written by Christopher Williams.
57
58			=head1 MAINTAINER
59
60			Shaun ASHBY L<mailTo:Shaun.Ashby@cern.ch>
61
62			=cut
63	sashby	1.8
64	williamc	1.4	package Utilities::CVSmodule;
65	williamc	1.1	require Exporter;
66	williamc	1.4	use Utilities::AddDir;
67			require 5.004;
68	williamc	1.1	@ISA= qw(Exporter);
69
70			sub new {
71			my $class=shift;
72	williamc	1.4	my $self={};
73			bless $self, $class;
74	williamc	1.1	$self->{myenv}={};
75			$self->{cvs}='cvs';
76			# Reset All variables
77			$self->{auth}="";
78			$self->{passkey}="";
79			$self->{user}="";
80			$self->{base}="";
81	williamc	1.5	$self->set_passbase("/tmp/".$>."CVSmodule/.cvspass");
82	williamc	1.1	return $self;
83			}
84
85			sub set_passbase {
86			my $self=shift;
87	williamc	1.4	my $file=shift;
88	williamc	1.1
89	williamc	1.4	my $dir;
90			($dir=$file)=~s/(.)\/./$1/;
91			AddDir::adddir($dir);
92			$self->{passbase}=$file;
93			$self->env("CVS_PASSFILE", $file);
94	williamc	1.1	}
95
96			sub set_passkey {
97			use Utilities::SCRAMUtils;
98			$self=shift;
99			$self->{passkey}=shift;
100			my $file=$self->{passbase};
101			SCRAMUtils::updatelookup($file,
102			$self->{cvsroot}." ", $self->{passkey});
103			}
104
105			sub set_base {
106			$self=shift;
107			$self->{base}=shift;
108			$self->_updatecvsroot();
109			}
110
111			sub get_base {
112			}
113
114			sub set_user {
115			$self=shift;
116			$self->{user}=shift;
117			if ( $self->{user} ne "" ) {
118			$self->{user}= $self->{user}.'@';
119			}
120			$self->_updatecvsroot();
121			}
122			sub set_auth {
123			$self=shift;
124			$self->{auth}=shift;
125			$self->{auth}=~s/^\:(.)\:*/\:$1\:/;
126	sashby	1.8
127	williamc	1.1	$self->_updatecvsroot();
128			}
129
130			sub env {
131			$self=shift;
132			my $name=shift;
133			$self->{myenv}{$name}=shift;
134			}
135
136			sub invokecvs {
137			$self=shift;
138			@cmds=@_;
139	sashby	1.7	# make sure weve got the right environment
140	williamc	1.1	foreach $key ( %{$self->{myenv}} ) {
141	williamc	1.4	$ENV{$key}=$self->{myenv}{$key};
142	williamc	1.1	}
143	sashby	1.7	# now perform the cvs command
144	williamc	1.6	return ( system( "$self->{cvs}" ,"-Q", "-d", "$self->{cvsroot}", @cmds ));
145	williamc	1.1	}
146
147			sub _updatecvsroot {
148			my $self=shift;
149			$self->{cvsroot}=$self->{auth}.$self->{user}.$self->{base};
150	williamc	1.4	}
151
152			sub cvsroot {
153			my $self=shift;
154			return $self->{cvsroot};
155	williamc	1.3	}
156
157			sub repository {
158			my $self=shift;
159			return $self->{base};
160	williamc	1.1	}