view release on metacpan or  search on metacpan

lib/Akamai/PropertyFetcher.pm  view on Meta::CPAN

26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
sub retrieve_property_data {
    my ($self) = @_;
    my $agent = $self->{agent};
    my $pm = Parallel::ForkManager->new($self->{max_processes});
 
    # 基本URL
    my $baseurl = "https://" . $agent->{host};
 
# Endpoint to retrieve contract IDs
my $contracts_endpoint = "$baseurl/papi/v1/contracts";
my $contracts_resp = $agent->get($contracts_endpoint);
die "Error retrieving contract ID: " . $contracts_resp->status_line unless $contracts_resp->is_success;
my $contracts_data = decode_json($contracts_resp->decoded_content);
my @contract_ids = map { $_->{contractId} } @{ $contracts_data->{contracts}->{items} };
 
# Endpoint to retrieve group IDs
my $groups_endpoint = "$baseurl/papi/v1/groups";
my $groups_resp = $agent->get($groups_endpoint);
die "Error retrieving group ID: " . $groups_resp->status_line unless $groups_resp->is_success;
my $groups_data = decode_json($groups_resp->decoded_content);
my @group_ids = map { $_->{groupId} } @{ $groups_data->{groups}->{items} };
 
# Process all combinations of contract IDs and group IDs
foreach my $contract_id (@contract_ids) {
    foreach my $group_id (@group_ids) {
        my $properties_endpoint = "$baseurl/papi/v1/properties?contractId=$contract_id&groupId=$group_id";
        my $properties_resp = $agent->get($properties_endpoint);
 
        if ($properties_resp->is_success) {
            # Retrieve property information
            my $properties_data = decode_json($properties_resp->decoded_content);
            my $properties = $properties_data->{properties}->{items};
 
            foreach my $property (@$properties) {
                # Fork a new process for each property
                $pm->start and next;
 
                my $property_id = $property->{propertyId};
                my $property_name = $property->{propertyName};
 
                # Create a directory for the property
                my $base_dir = "property";
                my $property_dir = File::Spec->catdir($base_dir, $property_name);
                make_path($property_dir) unless -d $property_dir;
 
                # Retrieve activated version information
                my $activations_endpoint = "$baseurl/papi/v1/properties/$property_id/activations?contractId=$contract_id&groupId=$group_id";
                my $activations_resp = $agent->get($activations_endpoint);
 
                if ($activations_resp->is_success) {
                    my $activations_data = decode_json($activations_resp->decoded_content);
 
                    # Sort activations to get the latest active versions for STAGING and PRODUCTION
                    my ($staging_version, $production_version);
                    foreach my $activation (sort { $b->{propertyVersion} <=> $a->{propertyVersion} } @{ $activations_data->{activations}->{items} }) {
                        if (!defined $staging_version && $activation->{network} eq 'STAGING' && $activation->{status} eq 'ACTIVE') {
                            $staging_version = $activation->{propertyVersion};
                        }

lib/Akamai/PropertyFetcher.pm  view on Meta::CPAN

88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
}
 
# If no active version found, skip to the next property
unless (defined $staging_version || defined $production_version) {
    warn "No active version found for property ($property_name) - Skipping\n";
    $pm->finish;
}
 
# Retrieve and save staging version details if an active version is found
if (defined $staging_version) {
    my $staging_rules_endpoint = "$baseurl/papi/v1/properties/$property_id/versions/$staging_version/rules?contractId=$contract_id&groupId=$group_id";
    my $staging_rules_resp = $agent->get($staging_rules_endpoint);
 
    if ($staging_rules_resp->is_success) {
        my $staging_rules_content = $staging_rules_resp->decoded_content;
        my $staging_file_path = File::Spec->catfile($property_dir, "staging.json");
 
        open my $fh, '>', $staging_file_path or die "Failed to create file: $staging_file_path";
        print $fh $staging_rules_content;
        close $fh;
 
        print "Saved staging environment active property details: $staging_file_path\n";
    } else {
        warn "Error retrieving staging version details ($property_name): " . $staging_rules_resp->status_line . " - Skipping\n";
    }
}
 
# Retrieve and save production version details if an active version is found
if (defined $production_version) {
    my $production_rules_endpoint = "$baseurl/papi/v1/properties/$property_id/versions/$production_version/rules?contractId=$contract_id&groupId=$group_id";
    my $production_rules_resp = $agent->get($production_rules_endpoint);
 
    if ($production_rules_resp->is_success) {
        my $production_rules_content = $production_rules_resp->decoded_content;
        my $production_file_path = File::Spec->catfile($property_dir, "production.json");
 
        open my $fh, '>', $production_file_path or die "Failed to create file: $production_file_path";
        print $fh $production_rules_content;
        close $fh;
 
        print "Saved production environment active property details: $production_file_path\n";