config.pm

mysql+ha. 实现高可用性 http://code.google.com/p/mysql-master-master/

            # skip if assigned not to requested host
            next unless ($ip_info->{assigned_to} eq $host);
            LogNotice("Clearing role '$role_name($ip)' from host '$host'. Role '$role_name($ip)' is orphaned now!");

            my $child_hosts = ClearChildRoles($role_name);
            push(@affected_hosts, @$child_hosts);
	    
            $ip_info->{assigned_to} = "";
        }

        # Notify all slave hosts on master changes
        if ($role_name eq $config->{active_master_role}) {
            my $slaves = GetSlavesList();
    	    push(@affected_hosts, @$slaves);
        }
    }

    # find unique elements set
    my %unique;
    @unique{@affected_hosts} = ();
    @affected_hosts = keys(%unique);
    
    return \@affected_hosts;
}

#-----------------------------------------------------------------
sub GetSlavesList() {
    my @slaves;
    my $hosts = $config->{host};
    foreach my $host (keys(%$hosts)) {
        if ($hosts->{$host}->{mode} eq 'slave') {
	        push (@slaves, $host);
	    }
    }
    
    return \@slaves;
}


#-----------------------------------------------------------------
sub CountHostRoles($) {
    my $host = shift;

    my $cnt = 0;
    foreach my $role_name (keys(%$roles)) {
        my $role = $roles->{$role_name};
        my $role_ips = $role->{ips};
        
        foreach my $ip (keys(%$role_ips)) {
            my $ip_info = $role_ips->{$ip};
            next unless ($ip_info->{assigned_to} eq $host);
            $cnt++;
        }
    }
    
    return $cnt;
}

#-----------------------------------------------------------------
sub FindEligibleHost($$) {
    my ($role_name, $ip) = @_;

    my $role_hosts = $roles->{$role_name}->{hosts};

    my $min_name = "";
    my $min_count = 0;

    foreach my $host (@$role_hosts) {
        next unless ($servers_status->{$host}->{state} eq 'ONLINE');
        my $cnt = CountHostRoles($host);
        if ($cnt < $min_count || $min_name eq "") {
            $min_name = $host;
            $min_count = $cnt;
        }
    }
    
    return $min_name;
}

#-----------------------------------------------------------------
sub NotifyAffectedHosts($) {
    my $role_name = shift;
    my $role = $roles->{$role_name};
    
    # Process all child roles
    my $child_roles = $role->{child_roles};
    foreach my $child (keys(%$child_roles)) {
        LogNotice("Found dependent child role '$child'. Notifying all affected hosts...");
	    my $child_ips = $roles->{$child}->{ips};

	    # Find assigned ips
	    foreach my $child_ip (keys(%$child_ips)) {
	        next if ($child_ips->{$child_ip}->{assigned_to} eq '');
		    
	        # Notify affected host
	        LogNotice("Notifying host $child_ips->{$child_ip}->{assigned_to} about parent state change.");
	        SendStatusToAgent($child_ips->{$child_ip}->{assigned_to});
	    }
    }
}

#-----------------------------------------------------------------
sub ProcessOrphanedRoles() {
    my $cnt = 0;
    
    foreach my $role_name (keys(%$roles)) {
        my $role = $roles->{$role_name};
        my $role_ips = $role->{ips};

        # Skip child roles with orphaned parents        
	    next if (IsOrphanedRole($role->{parent_role}));
	
        foreach my $ip (keys(%$role_ips)) {
            my $ip_info = $role_ips->{$ip};
            next unless ($ip_info->{assigned_to} eq "");
            
            # Find for eligible host
            my $host = FindEligibleHost($role_name, $ip);
            
            # Skip this role if no eligible hosts found
            last unless ($host);
            
            # Assign this ip to host
            $ip_info->{assigned_to} = $host;
            LogNotice("Role '$role_name($ip)' is not orphaned now. It has beed attached to '$host'.");
	    
	        # Send notification to all affected hosts
	        NotifyAffectedHosts($role_name);	    
	    
            # Notify all slave hosts on master changes
	        if ($role_name eq $config->{active_master_role}) {
                my $slaves = GetSlavesList();
		        foreach my $slave (@$slaves) {
                    # Notify affected host
	                LogDebug("Notifying host $slave about master state change.");
	                SendStatusToAgent($slave);
		        }
            }

            $cnt++;
        }
    }
    
    return $cnt;
}

#-----------------------------------------------------------------
sub FindAllEligibleHosts($) {
    my ($role_name) = @_;

    my $role_hosts = $roles->{$role_name}->{hosts};

    my $eligible_hosts = {};

    foreach my $host (@$role_hosts) {
        next unless ($servers_status->{$host}->{state} eq 'ONLINE');
        my $cnt = CountHostRoles($host);
        $eligible_hosts->{$host} = $cnt;
    }
    
    return $eligible_hosts;
}

#-----------------------------------------------------------------
sub MoveOneRoleIP($$$) {
    my ($role_name, $host1, $host2) = @_;
    
    my $role = $roles->{$role_name};
    my $role_ips = $role->{ips};
    
    foreach my $ip (keys(%$role_ips)) {
        my $ip_info = $role_ips->{$ip};
        next unless ($ip_info->{assigned_to} eq $host1);
        LogNotice("Moving role '$role_name($ip)' from $host1 to $host2");
        $ip_info->{assigned_to} = $host2;
        last;
    }

    # Send notification to all affected hosts
    NotifyAffectedHosts($role_name);

    # Notify all slave hosts on master changes
    if ($role_name eq $config->{active_master_role}) {
        my $slaves = GetSlavesList();
        foreach my $slave (@$slaves) {
            # Notify affected host
	        LogNotice("Notifying host $slave about master state change.");
	        SendStatusToAgent($slave);
	    }
    }
}


#-----------------------------------------------------------------
sub BalanceRoles() {
    my $cnt = 0;
    
    foreach my $role_name (keys(%$roles)) {
        my $role = $roles->{$role_name};
        my $role_ips = $role->{ips};
        
        next unless ($role->{mode} eq 'balanced');

        # Skip child roles with orphaned parents
	    next if (IsOrphanedRole($role->{parent_role}));

        my $hosts = FindAllEligibleHosts($role_name);
        next if (scalar(keys(%$hosts)) < 2);
        
        while(1) {
            my $max_name = "";
            my $min_name = "";
            
            foreach my $host (keys(%$hosts)) {
                if ($max_name eq "" || $hosts->{$host} > $hosts->{$max_name}) {
                    $max_name = $host;
                }
                if ($min_name eq "" || $hosts->{$host} < $hosts->{$min_name}) {
                    $min_name = $host;
                }
            }
            
            print "MAX: $max_name = $hosts->{$max_name}\n";
            print "MIN: $min_name = $hosts->{$min_name}\n";
            
            if ($hosts->{$max_name} - $hosts->{$min_name} < 2) {
                last;
            }
            
            MoveOneRoleIP($role_name, $max_name, $min_name);
            $hosts->{$max_name}--;
            $hosts->{$min_name}++;
        }
    }
    
    return $cnt;
}

#-----------------------------------------------------------------
sub GetExclusiveRoleOwner($) {
    my ($role) = @_;
    
    my $role = $roles->{$role};
    my $role_ips = $role->{ips};
    my @all_ips = keys(%$role_ips);
    my $ip = $all_ips[0];
    return $role_ips->{$ip}->{assigned_to};
}


#-----------------------------------------------------------------
sub MoveExclusiveRole($$) {
    my ($role, $host) = @_;
    
    my $role = $roles->{$role};
    my $role_ips = $role->{ips};
    my @all_ips = keys(%$role_ips);
    my $ip = $all_ips[0];
    $role_ips->{$ip}->{assigned_to} = $host;

    # Send notification to all affected hosts
    NotifyAffectedHosts($role);

    # Notify all slave hosts on master changes
    if ($role eq $config->{active_master_role}) {
        my $slaves = GetSlavesList();
        foreach my $slave (@$slaves) {
            # Notify affected host
	        LogNotice("Notifying host $slave about master state change.");
	        SendStatusToAgent($slave);
	    }
    }
}

#-----------------------------------------------------------------
sub OrphanExclusiveRole($) {
    my $role = shift;
    
    my $role = $roles->{$role};
    my $role_ips = $role->{ips};
    my @all_ips = keys(%$role_ips);
    my $ip = $all_ips[0];
    my $old_owner = $role_ips->{$ip}->{assigned_to};
    $role_ips->{$ip}->{assigned_to} = "";

    my $child_hosts = ClearChildRoles($role);
    foreach my $child (@$child_hosts) {
        LogNotice("Notifying affected host $child about role clear.");
        SendStatusToAgent($child);
    }

    # Notify all slave hosts on master changes
    if ($role eq $config->{active_master_role}) {
        my $slaves = GetSlavesList();
        foreach my $slave (@$slaves) {
            # Notify affected host
	        LogNotice("Notifying host $slave about master state change.");
	        SendStatusToAgent($slave);
	    }
    }
    
    return $old_owner;
}

#-----------------------------------------------------------------
sub IsOrphanedRole($) {
    my $role = shift;
    
    return 0 if ($role eq '');
    
    my $role = $roles->{$role};
    my $role_ips = $role->{ips};
    my @all_ips = keys(%$role_ips);
    my $ip = $all_ips[0];
    my $old_owner = $role_ips->{$ip}->{assigned_to};

    return ($old_owner eq "");
}

1;