Newer
Older
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
package alma.TMCDB.MonitorCollectorImpl;
import java.io.Serializable;
import java.util.List;
import java.util.logging.Logger;
import org.jacorb.orb.ORB;
import org.jacorb.orb.TypeCode;
import org.jacorb.orb.util.CorbaLoc;
import org.jacorb.poa.POA;
import org.omg.CORBA.Any;
import org.omg.CORBA.Context;
import org.omg.CORBA.ContextList;
import org.omg.CORBA.DomainManager;
import org.omg.CORBA.ExceptionList;
import org.omg.CORBA.NVList;
import org.omg.CORBA.NamedValue;
import org.omg.CORBA.Object;
import org.omg.CORBA.Policy;
import org.omg.CORBA.Request;
import org.omg.CORBA.SetOverrideType;
import org.omg.CORBA.SystemException;
import org.omg.CORBA.TCKind;
import org.omg.PortableServer.Servant;
import alma.ACS.CBDescIn;
import alma.ACS.CBDescInHelper;
import alma.ACS.CBDescInHolder;
import alma.ACS.CBDescOut;
import alma.ACS.CBdouble;
import alma.ACS.CBdoublePOA;
import alma.ACS.Callback;
import alma.ACS.CallbackOperations;
import alma.ACS.Monitor;
import alma.ACS.MonitorHelper;
import alma.ACS.OffShoot;
import alma.ACS.OffShootHelper;
import alma.ACS.OffShootOperations;
import alma.ACS.Plong;
import alma.ACS.PlongHelper;
import alma.ACS.PlongPOA;
import alma.ACS.PlongPOATie;
import alma.ACS.Property;
import alma.ACSErr.Completion;
import alma.JavaContainerError.wrappers.AcsJContainerServicesEx;
import alma.TMCDB.MonitorBlob;
import alma.TMCDB.doubleBlobData;
import alma.acs.container.ContainerServices;
public abstract class MonitorPointHelper extends MonitorPointBase implements CallbackOperations {
/**
*
*/
private static final long serialVersionUID = 1L;
/* protected String propertyName_m; /// property name
protected long archivingInterval_m; // interval in which the value should be archived (and so monitored)
private double valuePercentTrigger_m=0; // Delta value percentage a value can change before the value should be archived (and so monitored)
protected MonitorBlob monitorBlob_m; ///here we put the values
protected Monitor monitor_m = null; /// monitor of the property
//Subscription_var subscription_m; /// Subscription for the alarm of the property
OffShoot monitorCallback_m; ///callback CORBA reference
//OffShoot alarmCallback_m; ///callback CORBA reference
protected int curSeqPos_m = 0; ///current position to write in the sequence
protected int curSeqInit_m = 0; ///current init of the circular buffer
protected boolean bufferFull; ///status of buffer. If false data is sorted normally. If true buffer is full (data is stored but old data lost)
protected int seqLen_m; ///sequence length
protected boolean monitorSuppressed_m =false;
//protected boolean alarmSuppressed_m=false ;
//double alarmTimerTrigger_m;
protected final int maxSeqSegments_m = 2; // maximum sequence segments. maxSeqSegments_m*prealocSeqLen_m defines the buffer maximum size
protected final int prealocSeqLen_m = 100; // preallocated length of the sequence. This is the step that the sequence will grow
Long backLogSize_m;
Property property_m;*/
//TBLOB_SEQ[] blobDataSeq_m;
//org.omg.CORBA.Any[] blobDataSeqTemp_m;
/*private double valueTrigger_m=0; // Delta value describing how much a value can change before the value should be archived (and so monitored)
Logger m_logger;*/
protected OffShoot monitorServant_m;
public MonitorPointHelper(Logger log, String propertyName, long archivingInterval, Property propertyRef, MonitorBlob mb) {
this.propertyName_m=propertyName;
this.archivingInterval_m=archivingInterval;
this.property_m =propertyRef;
monitorBlob_m=mb;
monitorBlob_m.archiveOnChange = false;
monitorBlob_m.propertyName = propertyName;
monitorBlob_m.blobDataSeq = ORB.init().create_any();
m_logger=log;
valueTrigger_m =0;
{
Any anyCharacteristic = ORB.init().create_any() ;
String strCharacteristic;
anyCharacteristic = property_m.get_characteristic_by_name("archive_suppress");
strCharacteristic = anyCharacteristic.extract_string();
System.out.println("----------------->Archive Suppress:"+strCharacteristic);
if ( strCharacteristic.equals("true")) {
m_logger.info("Values from property "+ propertyName_m+" will NOT be collected because archive_suppress is set to:"+strCharacteristic);
}
double archiveMaxInt;
Any anyCharacteristic1 = ORB.init().create_any() ;
String strCharacteristic1;
anyCharacteristic1 = property_m.get_characteristic_by_name("archive_max_int");
strCharacteristic1 = anyCharacteristic1.extract_string();
archiveMaxInt= Double.parseDouble(strCharacteristic1)*(10000000.0); //we have to convert to 100s nsec.
if (archiveMaxInt==0.0 )
{
m_logger.info("Values from property "+ propertyName_m+" will NOT be collected because by time interval, because archive_max_int is 0");
//archivingInterval_m = 0;
}
} catch(SystemException ex) {
m_logger.info("CORBA problem in MonitorPoint:"+ ex.getMessage());
} catch(Exception e) {
m_logger.info("Problems in MonitorPoint:"+ e.getMessage());
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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
}
@Override
public boolean negotiate(long time_to_transmit, CBDescOut desc) {
return true;
}
@Override
public void activate(ContainerServices containerServices_m) {
}
@Override
public void deactivate(ContainerServices containerServices_m) {
}
@Override
public void startMonitoring(ContainerServices containerServices_m) {
CBDescIn cbDescIn =new CBDescIn(0,0,0);
try {
if (monitor_m!=null) {
return;
}
Request req =null;
req=property_m._request("create_monitor");
org.omg.CORBA.Any cb =req.add_named_in_arg("CB");
cb.insert_Object(monitorServant_m._duplicate(),OffShootHelper.type());
org.omg.CORBA.Any cb1 =req.add_named_in_arg("CBDescIn");
CBDescInHelper.insert(cb1, cbDescIn);
req.set_return_type (MonitorHelper.type());
req.invoke();
if (req.result() != null)
{
org.omg.CORBA.Any id =req.return_value();
Object m=MonitorHelper.extract(id);
monitor_m = MonitorHelper.narrow(m);
if(monitorSuppressed_m == true)
monitor_m.suspend();
monitor_m.set_timer_trigger(archivingInterval_m);
//monitor_m->set_value_trigger(valueTrigger_m);
req = monitor_m._request("set_value_trigger");
org.omg.CORBA.Any vt =req.add_named_in_arg ("delta");
vt.insert_double(valueTrigger_m);
if(valueTrigger_m == 0) {
org.omg.CORBA.Any vt1=req.add_named_in_arg ("enable");
vt1.insert_boolean(false);
}
else {
org.omg.CORBA.Any vt2=req.add_named_in_arg ("enable");
vt2.insert_boolean(true);
}
org.omg.CORBA.TypeCode result_tc = ORB.init().get_primitive_tc(TCKind.tk_void);
req.set_return_type(result_tc);
req.invoke();
//monitor_m->set_value_percent_trigger(valuePercentTrigger_m);
req = monitor_m._request("set_value_percent_trigger");
org.omg.CORBA.Any vt3 =req.add_named_in_arg ("delta");
vt3.insert_double(valueTrigger_m);
if(valuePercentTrigger_m == 0) {
org.omg.CORBA.Any vt4=req.add_named_in_arg ("enable");
vt4.insert_boolean(false);
}
else {
org.omg.CORBA.Any vt5=req.add_named_in_arg ("enable");
vt5.insert_boolean(true);
}
req.set_return_type(result_tc);
req.invoke();
}else {
m_logger.severe("Jacorb problem!");
}
}catch (SystemException e) {
m_logger.severe("Jacorb problem! "+e.getMessage());
}
}
@Override
public void stopMonitoring() {
try
{
if ( monitor_m!=null )
monitor_m.destroy();
monitor_m = null;
}
catch(SystemException ex)
{
ex.printStackTrace();
}
}
@Override
public void enable_archiving() {
monitorSuppressed_m = false;
if ( monitor_m==null )
return; // The monitor does not exist.
monitor_m.resume();
}
@Override
public void suppress_archiving() {
monitorSuppressed_m = true;
if ( monitor_m==null )
return; // The monitor does not exist.
monitor_m.suspend();
}
@Override
public void set_archiving_interval(long time) {
if (monitor_m != null) {
// monitor.set_timer_trigger(archivingInterval);
monitor_m.set_timer_trigger(10000000);
}
}
@Override
public void setPropertySerialNumber(String[] serialNumbers) {
monitorBlob_m.propertySerialNumber = serialNumbers;
}
public void fillSeq() {
}
@Override
public String getPropertyName() {
return propertyName_m;
}
}