X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=dbsrgits%2FDBIx-Class-DeploymentHandler.git;a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FDeploymentHandler%2FDad.pm;h=1fb35204b5cb25f6c01efb8ca97fa5d3adcebee8;hp=e80df8d8232802d15e14a799cf915d1caffec2da;hb=2e3cccff896e3d8f98cfb3d1069be1c62cc24d69;hpb=34ac0a51e6b2dcebf3fbf19512fa42ebd3edc3b8 diff --git a/lib/DBIx/Class/DeploymentHandler/Dad.pm b/lib/DBIx/Class/DeploymentHandler/Dad.pm index e80df8d..1fb3520 100644 --- a/lib/DBIx/Class/DeploymentHandler/Dad.pm +++ b/lib/DBIx/Class/DeploymentHandler/Dad.pm @@ -1,53 +1,48 @@ package DBIx::Class::DeploymentHandler::Dad; +# ABSTRACT: Parent class for DeploymentHandlers + use Moose; use Method::Signatures::Simple; -use DBIx::Class::DeploymentHandler::Types; require DBIx::Class::Schema; # loaded for type constraint -require DBIx::Class::ResultSet; # loaded for type constraint use Carp::Clan '^DBIx::Class::DeploymentHandler'; +use DBIx::Class::DeploymentHandler::Logger; +use DBIx::Class::DeploymentHandler::Types; +use Log::Contextual ':log', -package_logger => + DBIx::Class::DeploymentHandler::Logger->new({ + env_prefix => 'DBICDH' + }); has schema => ( isa => 'DBIx::Class::Schema', is => 'ro', required => 1, - handles => ['schema_version'], ); -has upgrade_directory => ( # configuration - isa => 'Str', - is => 'ro', - required => 1, - default => 'sql', -); - -has backup_directory => ( # configuration +has backup_directory => ( isa => 'Str', is => 'ro', predicate => 'has_backup_directory', ); -has to_version => ( # configuration +has to_version => ( is => 'ro', + isa => 'Str', lazy_build => 1, ); -sub _build_to_version { $_[0]->schema->schema_version } +sub _build_to_version { $_[0]->schema_version } -has databases => ( # configuration - coerce => 1, - isa => 'DBIx::Class::DeploymentHandler::Databases', - is => 'ro', - default => sub { [qw( MySQL SQLite PostgreSQL )] }, +has schema_version => ( + is => 'ro', + isa => 'StrSchemaVersion', + lazy_build => 1, ); -has sqltargs => ( # configuration - isa => 'HashRef', - is => 'ro', - default => sub { {} }, -); +sub _build_schema_version { $_[0]->schema->schema_version } method install { + log_info { 'installing version ' . $self->to_version }; croak 'Install not possible as versions table already exists in database' if $self->version_storage_is_installed; @@ -60,9 +55,14 @@ method install { } sub upgrade { + log_info { 'upgrading' }; my $self = shift; + my $ran_once = 0; while ( my $version_list = $self->next_version_set ) { - my ($ddl, $upgrade_sql) = @{$self->upgrade_single_step($version_list)||[]}; + $ran_once = 1; + my ($ddl, $upgrade_sql) = @{ + $self->upgrade_single_step({ version_set => $version_list }) + ||[]}; $self->add_database_version({ version => $version_list->[-1], @@ -70,24 +70,37 @@ sub upgrade { upgrade_sql => $upgrade_sql, }); } + + log_warn { 'no need to run upgrade' } unless $ran_once; } sub downgrade { + log_info { 'downgrading' }; my $self = shift; + my $ran_once = 0; while ( my $version_list = $self->previous_version_set ) { - $self->downgrade_single_step($version_list); + $ran_once = 1; + $self->downgrade_single_step({ version_set => $version_list }); # do we just delete a row here? I think so but not sure - $self->delete_database_version({ version => $version_list->[-1] }); + $self->delete_database_version({ version => $version_list->[0] }); } + log_warn { 'no version to run downgrade' } unless $ran_once; } -method backup { $self->storage->backup($self->backup_directory) } +method backup { + log_info { 'backing up' }; + $self->storage->backup($self->backup_directory) +} __PACKAGE__->meta->make_immutable; 1; +# vim: ts=2 sw=2 expandtab + +__END__ + =pod =attr schema @@ -95,27 +108,19 @@ __PACKAGE__->meta->make_immutable; The L (B) that is used to talk to the database and generate the DDL. -# this should be in a different place, maybe the SQLT role -# this should be renamed -=attr upgrade_directory +=attr schema_version -The directory (default C<'sql'>) that upgrades are stored in +The version that the schema is currently at. Defaults to +C<< $self->schema->schema_version >>. =attr backup_directory -The directory that backups are stored in +The directory where backups are stored =attr to_version The version (defaults to schema's version) to migrate the database to -# this should be in a different place, maybe the SQLT role -=attr databases - -The types of databases (default C<< [qw( MySQL SQLite PostgreSQL )] >>) to -generate files for - - =method install $dh->install @@ -123,7 +128,7 @@ generate files for Deploys the current schema into the database. Populates C with C and C. -B: you typically need to call C<< $dh->prepare_install >> before you call +B: you typically need to call C<< $dh->prepare_deploy >> before you call this method. B: you cannot install on top of an already installed database @@ -142,7 +147,7 @@ returned from L. $dh->downgrade Downgrades the database one step at a time till L -returns C. Each downgrade step will delete a Cfrom the +returns C. Each downgrade step will delete a C from the version storage. =method backup @@ -155,72 +160,80 @@ assuming it will work. =head1 METHODS THAT ARE REQUIRED IN SUBCLASSES +=head2 deploy + +See L. + =head2 version_storage_is_installed - warn q(I can't version this database!) - unless $dh->version_storage_is_installed +See L. -return true iff the version storage is installed. +=head2 add_database_version -=head2 deploy +See L. - $dh->deploy +=head2 delete_database_version -Deploy the schema to the database. +See L. -=head2 add_database_version +=head2 next_version_set - $dh->add_database_version({ - version => '1.02', - ddl => $ddl # can be undef, - upgrade_sql => $sql # can be undef, - }); +See L. -Store a new version into the version storage +=head2 previous_version_set -=head2 delete_database_version +See L. - $dh->delete_database_version({ version => '1.02' }) +=head2 upgrade_single_step -simply deletes given database version from the version storage +See L. -=head2 next_version_set +=head2 downgrade_single_step - print 'versions to install: '; - while (my $vs = $dh->next_version_set) { - print join q(, ), @{$vs} - } - print qq(\n); +See L. -return an arrayref describing each version that needs to be -installed to upgrade to C<< $dh->to_version >>. +=head1 ORTHODOX METHODS -=head2 previous_version_set +These methods are not actually B as things will probably still work +if you don't implement them, but if you want your subclass to get along with +other subclasses (or more likely, tools made to use another subclass), you +should probably implement these too, even if they are no-ops. - print 'versions to uninstall: '; - while (my $vs = $dh->previous_version_set) { - print join q(, ), @{$vs} - } - print qq(\n); +=head2 database_version -return an arrayref describing each version that needs to be -"installed" to downgrade to C<< $dh->to_version >>. +see L -=head2 upgrade_single_step +=head2 prepare_deploy - my ($ddl, $sql) = @{$dh->upgrade_single_step($version_set)||[]} +see L -call a single upgrade migration. Takes an arrayref describing the version to -upgrade to. Optionally return an arrayref containing C<$ddl> describing -version installed and C<$sql> used to get to that version. +=head2 prepare_resultsource_install -=head2 downgrade_single_step +see L - $dh->upgrade_single_step($version_set); +=head2 install_resultsource -call a single downgrade migration. Takes an arrayref describing the version to -downgrade to. +see L -__END__ +=head2 prepare_upgrade + +see L + +=head2 prepare_downgrade + +see L + +=head2 SUBCLASSING + +All of the methods mentioned in L and +L can be implemented in any fashion you choose. In the +spirit of code reuse I have used roles to implement them in my two subclasses, +L and +L, but you are free to implement +them entirely in a subclass if you so choose to. + +For in-depth documentation on how methods are supposed to work, see the roles +L, +L, and +L. -vim: ts=2 sw=2 expandtab