cluster.cpp

GiPS是一个面向数据密集型应用的分布式文件系统

IceProxy::Cluster::ClerkCallBack::ice_staticId()
{
    return ::Cluster::ClerkCallBack::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::Cluster::ClerkCallBack::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Cluster::ClerkCallBack);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::Cluster::ClerkCallBack::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Cluster::ClerkCallBack);
}

bool
IceProxy::Cluster::operator==(const ::IceProxy::Cluster::ClerkCallBack& l, const ::IceProxy::Cluster::ClerkCallBack& r)
{
    return static_cast<const ::IceProxy::Ice::Object&>(l) == static_cast<const ::IceProxy::Ice::Object&>(r);
}

bool
IceProxy::Cluster::operator!=(const ::IceProxy::Cluster::ClerkCallBack& l, const ::IceProxy::Cluster::ClerkCallBack& r)
{
    return static_cast<const ::IceProxy::Ice::Object&>(l) != static_cast<const ::IceProxy::Ice::Object&>(r);
}

bool
IceProxy::Cluster::operator<(const ::IceProxy::Cluster::ClerkCallBack& l, const ::IceProxy::Cluster::ClerkCallBack& r)
{
    return static_cast<const ::IceProxy::Ice::Object&>(l) < static_cast<const ::IceProxy::Ice::Object&>(r);
}

bool
IceProxy::Cluster::operator<=(const ::IceProxy::Cluster::ClerkCallBack& l, const ::IceProxy::Cluster::ClerkCallBack& r)
{
    return l < r || l == r;
}

bool
IceProxy::Cluster::operator>(const ::IceProxy::Cluster::ClerkCallBack& l, const ::IceProxy::Cluster::ClerkCallBack& r)
{
    return !(l < r) && !(l == r);
}

bool
IceProxy::Cluster::operator>=(const ::IceProxy::Cluster::ClerkCallBack& l, const ::IceProxy::Cluster::ClerkCallBack& r)
{
    return !(l < r);
}

void
IceProxy::Cluster::ClusterMessenger::clerkCallBackRegister(const ::std::string& clerkIP, const ::Cluster::ClerkCallBackPrx& clerkcb, const ::Ice::Context* __ctx)
{
    int __cnt = 0;
    while(true)
    {
        ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
        try
        {
            __delBase = __getDelegate();
            ::IceDelegate::Cluster::ClusterMessenger* __del = dynamic_cast< ::IceDelegate::Cluster::ClusterMessenger*>(__delBase.get());
            __del->clerkCallBackRegister(clerkIP, clerkcb, __ctx);
            return;
        }
        catch(const ::IceInternal::LocalExceptionWrapper& __ex)
        {
            __handleExceptionWrapper(__delBase, __ex);
        }
        catch(const ::Ice::LocalException& __ex)
        {
            __handleException(__delBase, __ex, __cnt);
        }
    }
}

const ::std::string&
IceProxy::Cluster::ClusterMessenger::ice_staticId()
{
    return ::Cluster::ClusterMessenger::ice_staticId();
}

::IceInternal::Handle< ::IceDelegateM::Ice::Object>
IceProxy::Cluster::ClusterMessenger::__createDelegateM()
{
    return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Cluster::ClusterMessenger);
}

::IceInternal::Handle< ::IceDelegateD::Ice::Object>
IceProxy::Cluster::ClusterMessenger::__createDelegateD()
{
    return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Cluster::ClusterMessenger);
}

bool
IceProxy::Cluster::operator==(const ::IceProxy::Cluster::ClusterMessenger& l, const ::IceProxy::Cluster::ClusterMessenger& r)
{
    return static_cast<const ::IceProxy::Ice::Object&>(l) == static_cast<const ::IceProxy::Ice::Object&>(r);
}

bool
IceProxy::Cluster::operator!=(const ::IceProxy::Cluster::ClusterMessenger& l, const ::IceProxy::Cluster::ClusterMessenger& r)
{
    return static_cast<const ::IceProxy::Ice::Object&>(l) != static_cast<const ::IceProxy::Ice::Object&>(r);
}

bool
IceProxy::Cluster::operator<(const ::IceProxy::Cluster::ClusterMessenger& l, const ::IceProxy::Cluster::ClusterMessenger& r)
{
    return static_cast<const ::IceProxy::Ice::Object&>(l) < static_cast<const ::IceProxy::Ice::Object&>(r);
}

bool
IceProxy::Cluster::operator<=(const ::IceProxy::Cluster::ClusterMessenger& l, const ::IceProxy::Cluster::ClusterMessenger& r)
{
    return l < r || l == r;
}

bool
IceProxy::Cluster::operator>(const ::IceProxy::Cluster::ClusterMessenger& l, const ::IceProxy::Cluster::ClusterMessenger& r)
{
    return !(l < r) && !(l == r);
}

bool
IceProxy::Cluster::operator>=(const ::IceProxy::Cluster::ClusterMessenger& l, const ::IceProxy::Cluster::ClusterMessenger& r)
{
    return !(l < r);
}

void
IceDelegateM::Cluster::ClerkCallBack::reportState(::Cluster::HeartBeatMessage& hbMsg, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__connection.get(), __reference.get(), __Cluster__ClerkCallBack__reportState_name, ::Ice::Idempotent, __context, __compress);
    bool __ok = __og.invoke();
    try
    {
        ::IceInternal::BasicStream* __is = __og.is();
        if(!__ok)
        {
            try
            {
                __is->throwException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
            }
        }
        hbMsg.__read(__is);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

bool
IceDelegateM::Cluster::ClerkCallBack::replicaCopy(const ::Cluster::ReplicaInfo& repInfo, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__connection.get(), __reference.get(), __Cluster__ClerkCallBack__replicaCopy_name, ::Ice::Normal, __context, __compress);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        repInfo.__write(__os);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    try
    {
        ::IceInternal::BasicStream* __is = __og.is();
        if(!__ok)
        {
            try
            {
                __is->throwException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
            }
        }
        bool __ret;
        __is->read(__ret);
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

bool
IceDelegateM::Cluster::ClerkCallBack::replicaDelete(const ::std::string& replicaID, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__connection.get(), __reference.get(), __Cluster__ClerkCallBack__replicaDelete_name, ::Ice::Normal, __context, __compress);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(replicaID);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    try
    {
        ::IceInternal::BasicStream* __is = __og.is();
        if(!__ok)
        {
            try
            {
                __is->throwException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
            }
        }
        bool __ret;
        __is->read(__ret);
        return __ret;
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateM::Cluster::ClusterMessenger::clerkCallBackRegister(const ::std::string& clerkIP, const ::Cluster::ClerkCallBackPrx& clerkcb, const ::Ice::Context* __context)
{
    ::IceInternal::Outgoing __og(__connection.get(), __reference.get(), __Cluster__ClusterMessenger__clerkCallBackRegister_name, ::Ice::Normal, __context, __compress);
    try
    {
        ::IceInternal::BasicStream* __os = __og.os();
        __os->write(clerkIP);
        ::Cluster::__write(__os, clerkcb);
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    bool __ok = __og.invoke();
    try
    {
        ::IceInternal::BasicStream* __is = __og.is();
        if(!__ok)
        {
            try
            {
                __is->throwException();
            }
            catch(const ::Ice::UserException& __ex)
            {
                throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
            }
        }
    }
    catch(const ::Ice::LocalException& __ex)
    {
        throw ::IceInternal::LocalExceptionWrapper(__ex, false);
    }
}

void
IceDelegateD::Cluster::ClerkCallBack::reportState(::Cluster::HeartBeatMessage& hbMsg, const ::Ice::Context* __context)
{
    ::Ice::Current __current;
    __initCurrent(__current, __Cluster__ClerkCallBack__reportState_name, ::Ice::Idempotent, __context);
    while(true)
    {
        ::IceInternal::Direct __direct(__current);
        try
        {
            ::Cluster::ClerkCallBack* __servant = dynamic_cast< ::Cluster::ClerkCallBack*>(__direct.servant().get());
            if(!__servant)
            {
                ::Ice::OperationNotExistException __opEx(__FILE__, __LINE__);
                __opEx.id = __current.id;
                __opEx.facet = __current.facet;
                __opEx.operation = __current.operation;
                throw __opEx;
            }
            try
            {
                __servant->reportState(hbMsg, __current);
            }
            catch(const ::Ice::LocalException& __ex)
            {
                throw ::IceInternal::LocalExceptionWrapper(__ex, false);
            }
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
        return;
    }
}

bool
IceDelegateD::Cluster::ClerkCallBack::replicaCopy(const ::Cluster::ReplicaInfo& repInfo, const ::Ice::Context* __context)
{
    ::Ice::Current __current;
    __initCurrent(__current, __Cluster__ClerkCallBack__replicaCopy_name, ::Ice::Normal, __context);
    while(true)
    {
        ::IceInternal::Direct __direct(__current);
        bool __ret;
        try
        {
            ::Cluster::ClerkCallBack* __servant = dynamic_cast< ::Cluster::ClerkCallBack*>(__direct.servant().get());
            if(!__servant)
            {
                ::Ice::OperationNotExistException __opEx(__FILE__, __LINE__);
                __opEx.id = __current.id;
                __opEx.facet = __current.facet;
                __opEx.operation = __current.operation;
                throw __opEx;
            }
            try
            {
                __ret = __servant->replicaCopy(repInfo, __current);
            }
            catch(const ::Ice::LocalException& __ex)
            {
                throw ::IceInternal::LocalExceptionWrapper(__ex, false);
            }
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
        return __ret;
    }
}

bool
IceDelegateD::Cluster::ClerkCallBack::replicaDelete(const ::std::string& replicaID, const ::Ice::Context* __context)
{
    ::Ice::Current __current;
    __initCurrent(__current, __Cluster__ClerkCallBack__replicaDelete_name, ::Ice::Normal, __context);
    while(true)
    {
        ::IceInternal::Direct __direct(__current);
        bool __ret;
        try
        {
            ::Cluster::ClerkCallBack* __servant = dynamic_cast< ::Cluster::ClerkCallBack*>(__direct.servant().get());
            if(!__servant)
            {
                ::Ice::OperationNotExistException __opEx(__FILE__, __LINE__);
                __opEx.id = __current.id;
                __opEx.facet = __current.facet;
                __opEx.operation = __current.operation;
                throw __opEx;
            }
            try
            {
                __ret = __servant->replicaDelete(replicaID, __current);
            }
            catch(const ::Ice::LocalException& __ex)
            {
                throw ::IceInternal::LocalExceptionWrapper(__ex, false);
            }
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
        return __ret;
    }
}

void
IceDelegateD::Cluster::ClusterMessenger::clerkCallBackRegister(const ::std::string& clerkIP, const ::Cluster::ClerkCallBackPrx& clerkcb, const ::Ice::Context* __context)
{
    ::Ice::Current __current;
    __initCurrent(__current, __Cluster__ClusterMessenger__clerkCallBackRegister_name, ::Ice::Normal, __context);
    while(true)
    {
        ::IceInternal::Direct __direct(__current);
        try
        {
            ::Cluster::ClusterMessenger* __servant = dynamic_cast< ::Cluster::ClusterMessenger*>(__direct.servant().get());
            if(!__servant)
            {
                ::Ice::OperationNotExistException __opEx(__FILE__, __LINE__);
                __opEx.id = __current.id;
                __opEx.facet = __current.facet;
                __opEx.operation = __current.operation;
                throw __opEx;
            }
            try
            {
                __servant->clerkCallBackRegister(clerkIP, clerkcb, __current);
            }
            catch(const ::Ice::LocalException& __ex)
            {
                throw ::IceInternal::LocalExceptionWrapper(__ex, false);
            }
        }
        catch(...)
        {
            __direct.destroy();
            throw;
        }
        __direct.destroy();
        return;
    }