Your IP : 10.0.0.1


Current Path : /scripts/
Upload File :
Current File : //scripts/comet_license_registration_sync

#!/usr/local/cpanel/3rdparty/bin/perl
# cpanel - comet_license_registration_sync
#                                      Copyright 2025 WebPros International, LLC
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited.

package scripts::comet_license_registration_sync;

use strict;
use warnings;

use Whostmgr::CometBackup::Entitlement ();
use Whostmgr::CometBackup::Runtime     ();
use Cpanel::LoadFile                   ();
use Fcntl                              qw( :flock O_CREAT O_RDWR );

our $PENDING_FILE  = '/var/cpanel/comet_runtime.pending';
our $LOCK_FILE     = '/var/run/comet_license_runtime.lock';
our $DISABLED_FILE = '/var/cpanel/feature-flags/disable-cpanel-comet-backup-plugin';

our $PLUGIN_DIR     = '/var/cpanel/plugins/comet-backup';
our $APP_DIR        = '/var/cpanel/apps';
our $CONF_FILE      = 'whm-comet-backup.conf';
our $PLUGIN_CONF    = "$PLUGIN_DIR/$CONF_FILE";
our $REGISTERED_LOC = "$APP_DIR/$CONF_FILE";
our $FEATURE_CONF   = "$PLUGIN_DIR/comet_backup.json";
our $REGISTER_CMD   = '/usr/local/cpanel/bin/register_appconfig';
our $UNREGISTER_CMD = '/usr/local/cpanel/bin/unregister_appconfig';
our $FEATURESC_DIR  = '/usr/local/cpanel/Cpanel/Config/ConfigObj/Driver';
our $FEATURESC_FILE = "$FEATURESC_DIR/comet_backup.json";

# True when $path exists. Only ENOENT is "absent"; any other stat failure dies,
# so a run that cannot tell ends without unregistering the plugin.
sub _exists {
    my ($path) = @_;
    return 1 if stat $path;
    return 0 if $!{ENOENT};
    die "Cannot stat $path: $!\n";
}

# Runtime permission includes the explicit disaster-recovery exception.
sub has_entitlement {
    my $permission = Whostmgr::CometBackup::Entitlement::can_run();
    die "Cannot determine Comet recovery permission: $!\n" unless defined $permission;
    return $permission;
}

sub has_license {
    my $licensed = Whostmgr::CometBackup::Entitlement::is_licensed();
    die "Cannot determine Comet product license\n" unless defined $licensed;
    return $licensed;
}

sub is_retail_company {
    require Cpanel::License::CompanyID;
    require Whostmgr::CometBackup::Constants;
    my $id = Cpanel::License::CompanyID::get_company_id() // return 0;
    return $Whostmgr::CometBackup::Constants::RETAIL_STORE_URLS{$id} ? 1 : 0;
}

sub menu_available {
    return has_entitlement() || is_retail_company();
}

sub is_registered {
    return _exists($REGISTERED_LOC);
}

# The pending record precedes preflight, so failed package upgrades cannot
# strand a first installation on cores without the license bridge.
sub _bootstrap_retry {
    my ( $package_arg, $force_disabled ) = @_;
    require Cpanel::FileUtils::Write;
    Whostmgr::CometBackup::Runtime::record_package_intent($package_arg);
    Cpanel::FileUtils::Write::overwrite( $PENDING_FILE, "pending\n", 0600 );
    if ( defined $package_arg ) {
        Whostmgr::CometBackup::Runtime::sync_compat( !$force_disabled && !_exists($DISABLED_FILE) );
    }
    return;
}

sub _context {
    my ($force_disabled) = @_;
    my $enabled = !$force_disabled && !_exists($DISABLED_FILE);
    return {
        enabled => $enabled, active => $enabled && has_entitlement(),
        product => $enabled && has_license(), menu => $enabled && menu_available(), registered => is_registered()
    };
}

sub _unchanged {
    my ($force_disabled) = @_;
    my $context          = _context($force_disabled);
    my $expected         = $context->{active} ? ( $context->{product} ? "licensed\n" : "recovery\n" ) : '';
    my $state            = Cpanel::LoadFile::load_if_exists($Whostmgr::CometBackup::Runtime::STATE_FILE) // '';
    my $pending          = Cpanel::LoadFile::load_if_exists($PENDING_FILE)                               // '';
    Whostmgr::CometBackup::Runtime::sync_compat(0) if Whostmgr::CometBackup::Runtime::core_has_bridge();
    return $expected eq $state && Whostmgr::CometBackup::Runtime::configuration_matches( $context->{active} ) && !length($pending);
}

sub _lock {
    my ($try_lock) = @_;
    sysopen( my $lock, $LOCK_FILE, O_CREAT | O_RDWR, 0600 ) or die "Cannot open $LOCK_FILE: $!\n";
    if ( !flock( $lock, LOCK_EX | ( $try_lock ? LOCK_NB : 0 ) ) ) {
        return if $try_lock && ( $!{EWOULDBLOCK} || $!{EAGAIN} );
        die "Cannot lock $LOCK_FILE: $!\n";
    }
    return $lock;
}

sub _sync_runtime {
    my ( $context, $package_arg, $force_disabled ) = @_;
    Whostmgr::CometBackup::Runtime::sync( $context->{active}, $package_arg, $context->{enabled}, $context->{product} );
    my $current = _context($force_disabled);
    if ( grep { !$context->{$_} != !$current->{$_} } qw(active enabled product) ) {
        Whostmgr::CometBackup::Runtime::sync( $current->{active}, undef, $current->{enabled}, $current->{product} );
    }
    %$context = %$current;
    return;
}

sub _sync_menu {
    my ( $context, $force_disabled ) = @_;
    $context->{menu} = !$force_disabled && !_exists($DISABLED_FILE) && menu_available();
    if ( $context->{menu} && !$context->{registered} ) {
        Whostmgr::CometBackup::Runtime::run_command( $REGISTER_CMD, $PLUGIN_CONF );
    }
    elsif ( !$context->{menu} && $context->{registered} ) {
        Whostmgr::CometBackup::Runtime::run_command( $UNREGISTER_CMD, $PLUGIN_CONF );
    }
    return;
}

sub run {
    my ( $force_disabled, $package_arg, $check_only, $try_lock ) = @_;
    if ($check_only) {
        my $unchanged;
        my $ok = eval { $unchanged = _unchanged($force_disabled); 1; };
        if ( !$ok ) { warn "comet_license_registration_sync: local state check failed: $@"; return 1; }
        return 0 if $unchanged;
    }
    my $lock = _lock($try_lock) or return 0;
    my $context;
    my $ok = eval { _bootstrap_retry( $package_arg, $force_disabled ); $context = _context($force_disabled); 1; };
    if ( !$ok ) { warn "comet_license_registration_sync: cannot determine the license state, retry retained: $@"; return 1; }
    my $runtime_ok         = eval { _sync_runtime( $context, $package_arg, $force_disabled ); 1; };
    my $runtime_error      = $@;
    my $registration_ok    = eval { _sync_menu( $context, $force_disabled ); 1; };
    my $registration_error = $@;
    my $showcase_error     = sync_showcase( $context->{product} );
    warn "comet_license_registration_sync: runtime reconciliation failed: $runtime_error" unless $runtime_ok;
    warn "comet_license_registration_sync: UI reconciliation failed: $registration_error" unless $registration_ok;
    return 1                                                                              unless $runtime_ok && $registration_ok && !$showcase_error;

    if ( !unlink($PENDING_FILE) && !$!{ENOENT} ) { die "Cannot clear $PENDING_FILE: $!\n"; }
    return 0;
}

# Puts the Feature Showcase driver in place only for a product license,
# and removes it otherwise. Runs every time, so servers registered under the
# earlier rule, and a changed driver text, catch up.
sub sync_showcase {
    my ($is_entitled) = @_;

    if ( !$is_entitled ) {
        return 0 if unlink($FEATURESC_FILE) || $!{ENOENT};
        warn "comet_license_registration_sync: cannot remove $FEATURESC_FILE: $!\n";
        return 1;
    }

    my $ok = eval {
        require Cpanel::LoadFile;
        my $driver = Cpanel::LoadFile::load($FEATURE_CONF);
        if ( ( Cpanel::LoadFile::load_if_exists($FEATURESC_FILE) // '' ) ne $driver ) {
            require Cpanel::FileUtils::Write;
            Cpanel::FileUtils::Write::overwrite( $FEATURESC_FILE, $driver, 0644 );
        }
        1;
    };
    return 0 if $ok;
    warn "comet_license_registration_sync: cannot install $FEATURESC_FILE: $@";
    return 1;
}

exit run() unless caller;

1;