blob: 7731eb014dfb612a7185afa1e6cf04f341276952 (
plain)
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
|
/* -*- C++ -*- */
// $Id$
// ============================================================================
// = FILENAME
// Process_Strategy_Test.h
//
// = DESCRIPTION
// This file contains the definition of Counting_Service and
// Options. Some compilers need it in a .h file for template
// instantiation (such as AIX C Set ++).
//
// = AUTHOR
// Doug Schmidt and Kevin Boyle <kboyle@sanwafp.com>
//
// ============================================================================
#if !defined (PROCESS_STRATEGY_TEST_H)
#define PROCESS_STRATEGY_TEST_H
#include "ace/Event_Handler.h"
#include "ace/SOCK_Stream.h"
#include "ace/Svc_Handler.h"
// Forward decl.
class ACE_Thread_Manager;
class Counting_Service : public ACE_Svc_Handler <ACE_SOCK_STREAM, ACE_NULL_SYNCH>
// = TITLE
// Reads and increments the count in a shared file.
//
// = DESCRIPTION
// Objects of this class execute in a separate process as a
// result of the <ACE_Strategy_Acceptor> and
// <ACE_Process_Strategy>.
{
public:
Counting_Service (ACE_Thread_Manager * = 0);
// Constructor.
virtual int open (void *v);
// Hook that is used to initialize the service (called by the
// <ACE_Strategy_Acceptor::handle_input> Template Method).
protected:
// = Methods invoked via "pointer to method" table entry.
virtual int svc (void);
// Handle the THREAD case.
// = Operations corresponding to requests from the client.
int read (void);
// Execute the read operation on the file.
int inc (void);
// Execute the increment operation on the file.
// = Hooks called by <Reactor> and <Strategy_Acceptor>.
virtual int handle_input (ACE_HANDLE p = ACE_INVALID_HANDLE);
// Hook called by the <Reactor> when data arrives from the client.
virtual int handle_close (ACE_HANDLE = ACE_INVALID_HANDLE,
ACE_Reactor_Mask = ACE_Event_Handler::ALL_EVENTS_MASK);
// Closing down
};
class Process_Strategy : public ACE_Process_Strategy<Counting_Service>
{
public:
// Constructor
Process_Strategy (size_t n_processes = 1,
ACE_Event_Handler *acceptor = 0,
ACE_Reactor * = 0,
int flags = 0);
// Destructor
~Process_Strategy (void);
// Overwrite the process creation method to include connection
// counting
virtual int activate_svc_handler (Counting_Service *svc_handler,
void *arg = 0);
};
class Options : public ACE_Event_Handler
// = TITLE
// Maintains the options for this program.
{
public:
Options (void);
// Constructor.
~Options (void);
// Destructor.
int parse_args (int argc, char *argv[]);
// Read command-line arguments and initialize options.
enum Concurrency_Type
{
PROCESS, // Run the test in separate processes.
REACTIVE, // Run the test reactively in one thread.
THREAD // Run the test as in separate threads.
};
// = Get/set concurrency type.
Concurrency_Type concurrency_type (void);
void concurrency_type (Concurrency_Type);
ACE_File_Lock &file_lock (void);
// Returns the file lock.
const char *filename (void);
// Returns the filename that we're using as the lock.
ACE_Concurrency_Strategy <Counting_Service> *concurrency_strategy (void);
// Returns the concurrency strategy.
private:
Concurrency_Type concurrency_type_;
// Concurrency strategy that we're running.
ACE_File_Lock file_lock_;
// Lock for the counting file.
ACE_Concurrency_Strategy<Counting_Service> *concurrency_strategy_;
// Activation strategy that either forks a new process or spawns a
// new thread for each client connection.
const char *filename_;
// Name of the counting file.
};
#endif /* PROCESS_STRATEGY_TEST_H */
|
