IAS/iasServer.cpp at master · geozy/IAS · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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
85
86
87
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
/*
 * File:   iasServer.cpp
 * Author: georgez
 *
 * Created on 27 October 2014, 12:35
 */

#include "iasServer.h"
#include "iasData.h"
#include "task_impl.h"
#include "iasServiceManager.h"
#include "iaService.h"
#include "iasErrors.h"

iasServer::iasServer(boost::asio::io_service& io_service, short port, task* (*makeTask)())
    : acceptor_(io_service, tcp::endpoint(tcp::v4(), port)),
        socket_(io_service),
          _taskFactory(makeTask,8),
            tasks_(this,0)
  {

    _pServiceManager=std::make_shared<iasServiceManager>(this);
    std::cout << "iasServer Created" << std::endl;
    do_accept();
  }

iasServer::~iasServer() {
     std::cout << "iasServer Destroyed" << std::endl;
}

void iasServer::do_accept()
  {
    acceptor_.async_accept(socket_,
        [this](boost::system::error_code ec)
        {
          if (!ec)
          {
              //C++ 11 construct Session Object
              //std::shared_ptr<session>(_makeSession(&socket_,_pServer))->start();
              auto sess=std::shared_ptr<session>(new session(socket_,this));
              sess->start();
          }

          do_accept();
        });
  }

void iasServer::addTask(task* tp){
      tasks_.addTask(tp);
  }

// just delete for now
void iasServer::recycleTask(task* tp){
    _taskFactory.recycleTask(tp);
}

task* iasServer::fetchTask(std::shared_ptr<session> ps){
   return  _taskFactory.getTask(ps);
}

iaService* iasServer::getService(uint id){
    return _pServiceManager->getService(id);
}

iasServiceManager* iasServer::getServiceManager(){
    return _pServiceManager.get();
}

bool iasServer::preProcess(task* tp){
    auto impl=tp->getImpl();
    PACKETHEAD_PTR pData=impl->getHeader();

    std::cout << "iasServer PreProcess" << std::endl;

    if(pData->ais){
        std::cout << "iasServer PreProcess IAS Flag Set" << std::endl;


        // AIS Signal Set, so handle here
        switch(pData->ais){

            case IAS_SERVICE_PRODUCER:
            {
                std::string sn(pData->buffer);

                // producer requesting to set up service
                std::cout << "PreProcess: Service Producer" << std::endl;

                // check authentication

                // check service exists
                uint serviceid=_pServiceManager->getServiceID(sn);

                if(serviceid){
                    // if does pass back service reference (ref))
                    pData->sid=(uint32_t)serviceid;

                    // get service ptr
                    iaService* ps=_pServiceManager->getService(serviceid);

                    // Get Session Ptr
                    std::shared_ptr<session> sess=impl->getSession();

                    // connect service to session
                    ps->connect_service(sess,IAS_SERVICE_PRODUCER);

                    pData->result=0;
                    pData->length=sizeof(PACKETHEAD);
                    pData->datasize=0;
                    sess->writeResponse(tp);

                }else{
                    // Problem creating service

                }
            }
            break;

            case IAS_SERVICE_CONSUMER:
            {
                // consumer requesting service
                std::string sn(pData->buffer);
                // check authentication

                // check service exists
                uint serviceid=_pServiceManager->getServiceID(sn);

                if(serviceid){
                    // if does pass back service reference (ref))
                    pData->sid=(uint32_t)serviceid;

                    // get service ptr
                    iaService* ps=_pServiceManager->getService(serviceid);

                    // Get Session Ptr
                    std::shared_ptr<session> sess=impl->getSession();

                    // connect service to session
                    ps->connect_service(sess,IAS_SERVICE_CONSUMER);

                    pData->result=0;
                    pData->length=sizeof(PACKETHEAD);
                    pData->datasize=0;
                    sess->writeResponse(tp);
                }else{
                    // Could not connect
                }
            }
            break;

            //case IAS_SERVICE_DETACH:
                // called when consumer wants to detach from service

                //break;

            //case IAS_SERVICE_CLOSE:
                // called when producer wants to detach from service
                // if there are no other producers, all consumers are
                // notified. Service will remain until alliasServiceManager* getServiceManager(); consumer/
                // producers have left.

                //break;


        }

        return false;
    }

    return false;
}