1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one
3 * or more contributor license agreements. See the NOTICE file
4 * distributed with this work for additional information
5 * regarding copyright ownership. The ASF licenses this file
6 * to you under the Apache License, Version 2.0 (the
7 * "License"); you may not use this file except in compliance
8 * with the License. You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing,
13 * software distributed under the License is distributed on an
14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 * KIND, either express or implied. See the License for the
16 * specific language governing permissions and limitations
17 * under the License.
18 */
19
20 // This autogenerated skeleton file illustrates how to build a server.
21 // You should copy it to another filename to avoid overwriting it.
22
23 #include "ThreadsTest.h"
24 #include <thrift/protocol/TBinaryProtocol.h>
25 #include <thrift/server/TThreadPoolServer.h>
26 #include <thrift/server/TThreadedServer.h>
27 #include <thrift/transport/TServerSocket.h>
28 #include <thrift/transport/TTransportUtils.h>
29 #include <thrift/concurrency/Monitor.h>
30 #include <thrift/concurrency/ThreadManager.h>
31 #include <thrift/concurrency/ThreadFactory.h>
32 #if _WIN32
33 #include <thrift/windows/TWinsockSingleton.h>
34 #endif
35
36 using boost::shared_ptr;
37 using namespace apache::thrift;
38 using namespace apache::thrift::protocol;
39 using namespace apache::thrift::transport;
40 using namespace apache::thrift::server;
41 using namespace apache::thrift::concurrency;
42
43
44 class ThreadsTestHandler : virtual public ThreadsTestIf {
45 public:
ThreadsTestHandler()46 ThreadsTestHandler() {
47 // Your initialization goes here
48 }
49
threadOne(const int32_t sleep)50 int32_t threadOne(const int32_t sleep) {
51 // Your implementation goes here
52 printf("threadOne\n");
53 go2sleep(1, sleep);
54 return 1;
55 }
56
threadTwo(const int32_t sleep)57 int32_t threadTwo(const int32_t sleep) {
58 // Your implementation goes here
59 printf("threadTwo\n");
60 go2sleep(2, sleep);
61 return 1;
62 }
63
threadThree(const int32_t sleep)64 int32_t threadThree(const int32_t sleep) {
65 // Your implementation goes here
66 printf("threadThree\n");
67 go2sleep(3, sleep);
68 return 1;
69 }
70
threadFour(const int32_t sleep)71 int32_t threadFour(const int32_t sleep) {
72 // Your implementation goes here
73 printf("threadFour\n");
74 go2sleep(4, sleep);
75 return 1;
76 }
77
stop()78 int32_t stop() {
79 printf("stop\n");
80 server_->stop();
81 return 1;
82 }
83
setServer(boost::shared_ptr<TServer> server)84 void setServer(boost::shared_ptr<TServer> server) {
85 server_ = server;
86 }
87
88 protected:
go2sleep(int thread,int seconds)89 void go2sleep(int thread, int seconds) {
90 Monitor m;
91 Synchronized s(m);
92 for (int i = 0; i < seconds; ++i) {
93 fprintf(stderr, "Thread %d: sleep %d\n", thread, i);
94 try {
95 m.wait(1000);
96 } catch(const TimedOutException&) {
97 }
98 }
99 fprintf(stderr, "THREAD %d DONE\n", thread);
100 }
101
102 private:
103 boost::shared_ptr<TServer> server_;
104
105 };
106
main(int argc,char ** argv)107 int main(int argc, char **argv) {
108 #if _WIN32
109 transport::TWinsockSingleton::create();
110 #endif
111 int port = 9090;
112 shared_ptr<ThreadsTestHandler> handler(new ThreadsTestHandler());
113 shared_ptr<TProcessor> processor(new ThreadsTestProcessor(handler));
114 shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
115 shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
116 shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
117
118 /*
119 shared_ptr<ThreadManager> threadManager =
120 ThreadManager::newSimpleThreadManager(10);
121 shared_ptr<ThreadFactory> threadFactory =
122 shared_ptr<ThreadFactory>(new ThreadFactory());
123 threadManager->threadFactory(threadFactory);
124 threadManager->start();
125
126 shared_ptr<TServer> server =
127 shared_ptr<TServer>(new TThreadPoolServer(processor,
128 serverTransport,
129 transportFactory,
130 protocolFactory,
131 threadManager));
132 */
133
134 shared_ptr<TServer> server =
135 shared_ptr<TServer>(new TThreadedServer(processor,
136 serverTransport,
137 transportFactory,
138 protocolFactory));
139
140 handler->setServer(server);
141
142 server->serve();
143
144 fprintf(stderr, "done.\n");
145
146 return 0;
147 }
148
149