~ubuntu-branches/ubuntu/vivid/389-ds-base/vivid

        void *csn_pl_reg_id;            /* registration assignment for csn callbacks */

        unsigned long repl_state_flags; /* state flags                                                  */

        PRUint32    repl_flags;         /* persistent, externally visible flags */

        Slapi_Eq_Context repl_eqcxt_rs; /* context to cancel event that saves ruv */    

        Slapi_Eq_Context repl_eqcxt_tr; /* context to cancel event that reaps tombstones */     

        Object *repl_csngen;                    /* CSN generator for this replica */

static void _delete_tombstone(const char *tombstone_dn, const char *uniqueid, int ext_op_flags);

static void replica_strip_cleaned_rids(Replica *r);

 

 * various parts of the DIT. 

 */

Replica *

                goto done;

        }

 

        {

                if (NULL != errortext)

                {

        PR_ASSERT(NULL != r);

        if (NULL != r)

        {

                /* Make sure we dump the CSNGen state */

                r->repl_csn_assigned = PR_TRUE;

                /* This function take the Lock Inside */

                /* And also write the RUV */

                replica_update_state((time_t)0, r->repl_name);

void

replica_set_csn_assigned(Replica *r)

{

    r->repl_csn_assigned = PR_TRUE;

}

 

/* 

 

        if (r->repl_lock)

        {

                r->repl_lock = NULL;

        }

 

 

        PR_ASSERT(r);

 

        if (r->repl_state_flags & REPLICA_IN_USE)

        {

                if (isInc)

                slapi_ch_free_string(&r->locking_purl);

                r->locking_purl = slapi_ch_strdup(locking_purl);

        }

        return rval;

}

 

 

        PR_ASSERT(r);

        

        isInc = (r->repl_state_flags & REPLICA_INCREMENTAL_IN_PROGRESS);

        /* check to see if the replica is in use and log a warning if not */

        if (!(r->repl_state_flags & REPLICA_IN_USE))

                else

                        r->repl_state_flags &= ~(REPLICA_TOTAL_IN_PROGRESS);

        }

}

 

/* 

        ReplicaId rid;

        PR_ASSERT(r);

 

        rid = r->repl_rid;

        return rid;

}

 

{

        PR_ASSERT(r);

 

        r->repl_rid = rid;

}

 

/* Returns true if replica was initialized through ORC or import;

 

        PR_ASSERT(r);

 

 

        PR_ASSERT (r->repl_ruv);

 

 

        ruv = r->repl_ruv;

 

 

        return ruv;

}

{

        PR_ASSERT(r && ruv);

 

 

        if(NULL != r->repl_ruv) 

        {

        r->repl_ruv = object_new((void*)ruv, (FNFree)ruv_destroy);

        r->repl_ruv_dirty = PR_TRUE;

 

}

 

/*

        else

        {

                RUV *ruv;

                

                if (r->repl_ruv != NULL)

                {

                                slapi_sdn_get_dn(r->repl_root));

                        rc = RUV_NOTFOUND;

                }

        }

        return rc;

}

 

        PR_ASSERT(r);

 

 

        object_acquire (r->repl_csngen);

        csngen = r->repl_csngen;

 

 

        return csngen;

}

{

        PR_ASSERT(r);

 

        r->repl_type = type;

}

 

/* 

        char *replstate = NULL;

        PR_ASSERT(r);

 

 

    legacy2mmr = r->legacy_consumer && !legacy_consumer;

 

    }

 

    r->legacy_consumer = legacy_consumer;

 

    if (legacy2mmr)

    {

{

    char *purl;

 

 

    PR_ASSERT (r->legacy_consumer);

 

 

 

    return purl;

}

void 

replica_set_legacy_purl (Replica *r, const char *purl)

{

 

    PR_ASSERT (r->legacy_consumer);

 

 

    r->legacy_purl = slapi_ch_strdup (purl);

 

}

 

/* 

 

        PR_ASSERT (r);

 

 

    if (sdn == NULL)

    {

                result = replica_updatedn_list_ismember(r->updatedn_list, sdn);

    }

 

 

        return result;

}

{

        PR_ASSERT (r);

 

 

        if (!r->updatedn_list)

                r->updatedn_list = replica_updatedn_list_new(NULL);

        else if (SLAPI_IS_MOD_ADD(mod_op))

                replica_updatedn_list_add(r->updatedn_list, vs);

 

}

 

void

replica_reset_csn_pl(Replica *r)

{

 

    if (NULL != r->min_csn_pl){

        csnplFree (&r->min_csn_pl);

    }

    r->min_csn_pl = csnplNew();

 

}

 

/* gets current replica generation for this replica */

    int rc = 0;

    char *gen = NULL;

 

    {        

                

        if (rc == 0)

            gen = ruv_get_replica_generation ((RUV*)object_get_data (r->repl_ruv));

 

    }

 

    return gen;

    if (r == NULL)

        return;

 

 

    if (clear)

    {

        r->repl_flags |= flag;

    }

 

}

 

void replica_replace_flags (Replica *r, PRUint32 flags)

{

    if (r)

    {

        r->repl_flags = flags;

    }

}

 

void

replica_get_referrals(const Replica *r, char ***referrals)

{

    replica_get_referrals_nolock (r, referrals);

}

 

void

        csn = (CSN*)extracsn; /* use this csn to do the update */

    }

 

 

    gen = (CSNGen *)object_get_data (r->repl_csngen);

    PR_ASSERT (gen);

 

/* done: */

 

    if (csn != extracsn) /* do not free the given csn */

    {

        csn_free (&csn);

void

replica_dump(Replica *r)

{

 

 

    slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "Replica state:\n");      

    slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "\treplica root: %s\n",

    slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "\treplica id: %d\n", r->repl_rid);

    slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "\tflags: %d\n", r->repl_flags);

    slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "\tstate flags: %lu\n", r->repl_state_flags);

    slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "\tupdate dn: %s\n",

            updatedn_list? updatedn_list : "not configured");

    slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "\truv: %s configured and is %sdirty\n",

                    r->repl_ruv ? "" : "not", r->repl_ruv_dirty ? "" : "not ");

    slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "\tCSN generator: %s configured\n",

                    r->repl_csngen ? "" : "not");

        /* JCMREPL - Dump Referrals */

 

}

 

 

{

    CSN *csn;

 

 

    csn= _replica_get_purge_csn_nolock(r);

 

 

    return csn;

}

    

    PR_ASSERT (r);

 

 

    rc = replica_log_ruv_elements_nolock (r);

 

 

    return rc;

}

        int state_backend = -1;

        const char *mtn_state = NULL;

        

 

        if ( supplierRuv == NULL )

        {

                state_backend = 1;

        }

        /* Unlock to avoid changing MTN state under repl lock */

 

        if(state_backend == 0 )

        {

 

    PR_ASSERT (r);

 

 

    if (enable)

    {

        }   

    }

 

}

 

/* This function is generally called when replica's data store

 

    PR_ASSERT (r);

 

 

    old_ruv_obj = r->repl_ruv;

 

 

    rc = _replica_configure_ruv (r, PR_TRUE);

 

 

    if (rc != 0)

    {

           up to date using this changelog and hence will need to be reinitialized */

 

        /* replace ruv to make sure we work with the correct changelog file */

 

        new_ruv_obj = r->repl_ruv;

        r->repl_ruv = old_ruv_obj;

 

 

        rc = cl5GetUpperBoundRUV (r, &upper_bound_ruv);

        if (rc != CL5_SUCCESS && rc != CL5_NOTFOUND)

                rc = cl5DeleteDBSync (r_obj);

 

                /* reinstate new ruv */

 

                r->repl_ruv = new_ruv_obj;                

 

                    rc = replica_log_ruv_elements_nolock (r);

                }

 

            } 

            else

            {

                /* we just need to reinstate new ruv */

 

                r->repl_ruv = new_ruv_obj;

 

            }                           

        }

        else    /* upper bound vector is not there - we have no changes logged */

        {

            /* reinstate new ruv */

 

            r->repl_ruv = new_ruv_obj;

 

               a starting point for iteration through the changes */

            rc = replica_log_ruv_elements_nolock (r);

 

        }        

    }

 

 

                                        /* Update also the directory entry */

                                        if (RUV_UPDATE_PARTIAL == need_update) {

                                                replica_replace_ruv_tombstone(r);

                                        } else if (RUV_UPDATE_FULL == need_update) {

                                                _delete_tombstone(slapi_sdn_get_dn(r->repl_root), 

                                                                  RUV_STORAGE_ENTRY_UNIQUEID, 

                goto done;

        }

 

 

        /* replica state is currently being updated

           or no CSN was assigned - bail out */

        if (r->state_update_inprogress)

        {

                goto done;

        }

 

        if (!r->repl_csn_assigned)

        {

                /* EY: the consumer needs to flush ruv to disk. */

                if (replica_write_ruv(r)) {

                        slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,

                                "_replica_update_state: failed write RUV for %s\n",

        rc = csngen_get_state ((CSNGen*)object_get_data (r->repl_csngen), &smod);

        if (rc != 0)

        {

                goto done;

        }

 

                slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name,

                        "replica_update_state: failed to get the config dn for %s\n",

                        slapi_sdn_get_dn (r->repl_root));

                goto done;

        }

        pb = slapi_pblock_new();

        /* we don't want to held lock during operations since it causes lock contention

       and sometimes deadlock. So releasing lock here */

 

 

        /* replica repl_name and new_name attributes do not get changed once

       the replica is configured - so it is ok that they are outside replica lock */

 

        PR_ASSERT(r);

 

 

 

        PR_ASSERT (r->repl_ruv);

        

        ruv_to_smod ((RUV*)object_get_data(r->repl_ruv), &smod);

        ruv_last_modified_to_smod ((RUV*)object_get_data(r->repl_ruv), &smod_last_modified);

 

 

        mods [0] = (LDAPMod *)slapi_mod_get_ldapmod_byref(&smod);

        mods [1] = (LDAPMod *)slapi_mod_get_ldapmod_byref(&smod_last_modified);

        mods [2] = NULL;

        pb = slapi_pblock_new();

 

        slapi_modify_internal_set_pb_ext(

                pb,

                r->repl_root, /* only used to select be */

        slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &rc);

 

    /* ruv does not exist - create one */

 

    if (rc == LDAP_SUCCESS)

    {

                        slapi_sdn_get_dn(r->repl_root), rc);

        }

 

        

        slapi_mod_done (&smod);

        slapi_mod_done (&smod_last_modified);

done:

        if (replica)

        {

                replica->tombstone_reap_active = PR_FALSE;

        }

 

        if (NULL != purge_csn)

                        if (replica)

                        {

 

 

                                /* No action if purge is disabled or the previous purge is not done yet */

                                if (replica->tombstone_reap_interval != 0 &&

                                        }

                                }

                                /* reap thread will wait until this lock is released */

                        }

                        object_release(replica_object);

                        replica_object = NULL;

    ruv = (RUV*)object_get_data (ruv_obj);

    PR_ASSERT (ruv);

 

 

    r->repl_csn_assigned = PR_TRUE;

        

 

    ruv_add_csn_inprogress (ruv, csn);

 

 

    object_release (ruv_obj);

}

    ruv = (RUV*)object_get_data (ruv_obj);

    PR_ASSERT (ruv);

 

 

        if (NULL != r->min_csn_pl)

        {

        }

 

    ruv_cancel_csn_inprogress (ruv, csn);

 

    object_release (ruv_obj);

}

replica_set_purge_delay(Replica *r, PRUint32 purge_delay)

{

        PR_ASSERT(r);

        r->repl_purge_delay = purge_delay;

}

 

void

{

        char *repl_name;

 

 

        /*

         * Leave the event there to purge the existing tombstones

                        "tombstone_reap event (interval=%ld) was %s\n",

                        r->tombstone_reap_interval, (r->repl_eqcxt_tr ? "scheduled" : "not scheduled successfully"));

        }

}

 

static void

 

    replica_strip_cleaned_rids(r);

 

 

    PR_ASSERT (r->repl_ruv);

    ruv_to_smod ((RUV*)object_get_data(r->repl_ruv), &smod);

            "replica_replace_ruv_tombstone: "

            "failed to get the config dn for %s\n",

            slapi_sdn_get_dn (r->repl_root));

        goto bail;

    }

    mods[0] = (LDAPMod*)slapi_mod_get_ldapmod_byref(&smod);

    mods[1] = (LDAPMod*)slapi_mod_get_ldapmod_byref(&smod_last_modified);

 

 

    mods [2] = NULL;

    pb = slapi_pblock_new();

        {

                RUV *local_ruv = NULL;

 

 

                local_ruv =  (RUV*)object_get_data (r->repl_ruv);

 

                if(is_cleaned_rid(supplier_id) || local_ruv == NULL){

                        return;

                }

 

                        /* Replace it */

                        ruv_replace_replica_purl(local_ruv, supplier_id, supplier_purl);

                }

 

                /* Update also the directory entry */

                replica_replace_ruv_tombstone(r);

replica_set_ruv_dirty(Replica *r)

{

        PR_ASSERT(r);

        r->repl_ruv_dirty = PR_TRUE;

}

 

PRBool

    if (r == NULL)

        return;

 

 

    if (clear)

    {

        r->repl_state_flags |= flag;

    }

 

}

 

/**

    if (r == NULL)

        return;

 

}

 

/* replica just came back online, probably after data was reloaded */