void ACS_Base::ThrowInvalidState(const std::string& arLocation)
{
#ifndef OPENDNP3_STRIP_LOG_MESSAGES
MACRO_THROW_EXCEPTION_COMPLEX(InvalidStateException, "State: " << this->Name());
#else
MACRO_THROW_EXCEPTION_COMPLEX(InvalidStateException, "");
#endif
}
void PhysicalLayerAsyncBase::OnOpenCallback(const boost::system::error_code& arErr)
{
if(mState.mOpening) {
mState.mOpening = false;
this->DoOpenCallback();
if(arErr) {
LOG_BLOCK(LEV_WARNING, arErr.message());
mState.CheckForClose();
this->DoOpenFailure();
if(mpHandler) mpHandler->OnOpenFailure();
}
else { // successful connection
if(this->IsClosing()) { // but the connection was closed
mState.CheckForClose();
this->DoClose();
if(mpHandler) mpHandler->OnOpenFailure();
}
else {
mState.mOpen = true;
this->DoOpenSuccess();
if(mpHandler) mpHandler->OnLowerLayerUp();
}
}
}
else {
MACRO_THROW_EXCEPTION_COMPLEX(InvalidStateException, "OnOpenCallback: " << this->ConvertStateToString());
}
}
///////////////////////////////////////
// ILayerDown NVII implementations
///////////////////////////////////////
void TransportLayer::_Send(const uint8_t* apData, size_t aNumBytes)
{
if(aNumBytes == 0 || aNumBytes > M_FRAG_SIZE) {
MACRO_THROW_EXCEPTION_COMPLEX(ArgumentException, "Illegal arg: " << aNumBytes << ", Array length must be in the range [1," << M_FRAG_SIZE << "]");
}
mpState->Send(apData, aNumBytes, this);
}
void PhysicalLayerAsyncBase::AsyncOpen()
{
if(mState.CanOpen()) {
mState.mOpening = true;
this->DoOpen();
}
else {
MACRO_THROW_EXCEPTION_COMPLEX(InvalidStateException, "AsyncOpen: " << this->ConvertStateToString());
}
}
BufferTypes Convert(DataTypes aType)
{
switch(aType) {
case(DT_BINARY): return BT_BINARY;
case(DT_ANALOG): return BT_ANALOG;
case(DT_COUNTER): return BT_COUNTER;
default:
MACRO_THROW_EXCEPTION_COMPLEX(ArgumentException, "Invalid conversion to BufferType: " << aType);
}
}
void PhysicalLayerAsyncBase::AsyncRead(uint8_t* apBuff, size_t aMaxBytes)
{
if(aMaxBytes < 1) {
MACRO_THROW_EXCEPTION(ArgumentException, "aMaxBytes must be > 0");
}
if(mState.CanRead()) {
mState.mReading = true;
this->DoAsyncRead(apBuff, aMaxBytes);
}
else {
MACRO_THROW_EXCEPTION_COMPLEX(InvalidStateException, "AsyncRead: " << this->ConvertStateToString());
}
}
void PhysicalLayerAsyncBase::AsyncWrite(const uint8_t* apBuff, size_t aNumBytes)
{
if(aNumBytes < 1) {
MACRO_THROW_EXCEPTION(ArgumentException, "aNumBytes must be > 0");
}
if(mState.CanWrite()) {
mState.mWriting = true;
this->DoAsyncWrite(apBuff, aNumBytes);
}
else {
MACRO_THROW_EXCEPTION_COMPLEX(InvalidStateException, "AsyncWrite: " << this->ConvertStateToString());
}
}
void PhysicalLayerAsyncBase::StartClose()
{
if(!mState.IsClosing()) { //TODO - kind of hack as it deviates from the current model.
if(mState.CanClose()) {
mState.mClosing = true;
if(mState.mOpening) this->DoOpeningClose();
else this->DoClose();
}
else {
MACRO_THROW_EXCEPTION_COMPLEX(InvalidStateException, "StartClose: " << this->ConvertStateToString());
}
}
}
IOutstation* DNP3Channel::AddOutstation(const std::string& arLoggerId, FilterLevel aLevel, ICommandHandler* apCmdHandler, const SlaveStackConfig& arCfg)
{
LinkRoute route(arCfg.link.RemoteAddr, arCfg.link.LocalAddr);
ExecutorPause p(mpPhys->GetExecutor());
if(mRouter.IsRouteInUse(route)) {
MACRO_THROW_EXCEPTION_COMPLEX(ArgumentException, "Route already in use: " << route);
}
else {
auto pLogger = mpLogger->GetSubLogger(arLoggerId, aLevel);
auto pOutstation = new OutstationStackImpl(pLogger, mpService, mpPhys->GetExecutor(), apCmdHandler, arCfg, [this, route](IStack * apStack) {
this->OnStackShutdown(apStack, route);
});
pOutstation->SetLinkRouter(&mRouter);
mStacks.insert(pOutstation);
mRouter.AddContext(pOutstation->GetLinkContext(), route);
return pOutstation;
}
}
IMaster* DNP3Channel::AddMaster(const std::string& arLoggerId, FilterLevel aLevel, IDataObserver* apPublisher, const MasterStackConfig& arCfg)
{
LinkRoute route(arCfg.link.RemoteAddr, arCfg.link.LocalAddr);
ExecutorPause p(mpPhys->GetExecutor());
if(mRouter.IsRouteInUse(route)) {
MACRO_THROW_EXCEPTION_COMPLEX(ArgumentException, "Route already in use: " << route);
}
else {
auto pLogger = mpLogger->GetSubLogger(arLoggerId, aLevel);
auto pMaster = new MasterStackImpl(pLogger, mpService, mpPhys->GetExecutor(), apPublisher, &mGroup, arCfg, [this, route](IStack * apStack) {
this->OnStackShutdown(apStack, route);
});
pMaster->SetLinkRouter(&mRouter);
mStacks.insert(pMaster);
mRouter.AddContext(pMaster->GetLinkContext(), route);
return pMaster;
}
}
void PhysicalLayerAsyncBase::OnWriteCallback(const boost::system::error_code& arErr, size_t aNumBytes)
{
if(mState.mWriting) {
mState.mWriting = false;
if(arErr) {
LOG_BLOCK(LEV_WARNING, arErr.message());
if(mState.CanClose()) this->StartClose();
}
else {
if(mState.mClosing) {
LOG_BLOCK(LEV_DEBUG, "Ignoring written bytes since layer is closing: " << aNumBytes);
}
else {
this->DoWriteSuccess();
}
}
if(mState.CheckForClose()) this->DoThisLayerDown();
}
else {
MACRO_THROW_EXCEPTION_COMPLEX(InvalidStateException, "OnWriteCallback: " << this->ConvertStateToString());
}
}
void PhysicalLayerAsyncBase::OnReadCallback(const boost::system::error_code& arErr, uint8_t* apBuff, size_t aSize)
{
if(mState.mReading) {
mState.mReading = false;
if(arErr) {
LOG_BLOCK(LEV_WARNING, arErr.message());
if(mState.CanClose()) this->StartClose();
}
else {
if(mState.mClosing) {
LOG_BLOCK(LEV_DEBUG, "Ignoring received bytes since layer is closing: " << aSize);
}
else {
this->DoReadCallback(apBuff, aSize);
}
}
if(mState.CheckForClose()) this->DoThisLayerDown();
}
else {
MACRO_THROW_EXCEPTION_COMPLEX(InvalidStateException, "OnReadCallback: " << this->ConvertStateToString());
}
}
