← Back to branch summary

~ubuntu-branches/ubuntu/trusty/nordugrid-arc/trusty

« back to all changes in this revision

Viewing changes to src/libs/data-staging/DataDeliveryRemoteComm.cpp

  • Committer: Package Import Robot
  • Author(s): Mattias Ellert
  • Date: 2013-11-29 13:39:10 UTC
  • mfrom: (3.1.16 sid)
  • Revision ID: package-import@ubuntu.com-20131129133910-sy6ayoavphc5hozs
Tags: 4.0.0-1
http://bugs.debian.org/715131
https://launchpad.net/bugs/1049798
4.0.0 Release (Closes: #715131) (LP: #1049798)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libs/data-staging/DataDeliveryRemoteComm.cpp
39
39
      surl = dtr->get_source()->TransferLocations()[0].fullstr();
40
40
    }
41
41
    else {
42
 
      logger_->msg(Arc::ERROR, "DTR %s: No locations defined for %s", dtr_id, dtr->get_source()->str());
 
42
      logger_->msg(Arc::ERROR, "No locations defined for %s", dtr->get_source()->str());
43
43
      return;
44
44
    }
45
45
 
46
46
    if (dtr->get_destination()->TransferLocations().empty()) {
47
 
      logger_->msg(Arc::ERROR, "DTR %s: No locations defined for %s", dtr_id, dtr->get_destination()->str());
 
47
      logger_->msg(Arc::ERROR, "No locations defined for %s", dtr->get_destination()->str());
48
48
      return;
49
49
    }
50
50
    std::string durl = dtr->get_destination()->TransferLocations()[0].fullstr();
64
64
    }
65
65
 
66
66
    // connect to service and make a new transfer request
67
 
    logger_->msg(Arc::VERBOSE, "DTR %s: Connecting to Delivery service at %s",
68
 
                 dtr_id, endpoint.str());
 
67
    logger_->msg(Arc::VERBOSE, "Connecting to Delivery service at %s", endpoint.str());
69
68
    client = new Arc::ClientSOAP(cfg, endpoint, timeout);
70
69
 
71
70
    Arc::NS ns;
91
90
    // delegate credentials
92
91
    Arc::XMLNode op = request.Child(0);
93
92
    if (!SetupDelegation(op, dtr->get_usercfg())) {
94
 
      logger_->msg(Arc::ERROR, "DTR %s: Failed to set up credential delegation with %s",
95
 
                   dtr_id, endpoint.str());
 
93
      logger_->msg(Arc::ERROR, "Failed to set up credential delegation with %s", endpoint.str());
96
94
      return;
97
95
    }
98
96
 
99
97
    std::string xml;
100
98
    request.GetXML(xml, true);
101
 
    logger_->msg(Arc::DEBUG, "DTR %s: Request:\n%s", dtr_id, xml);
 
99
    logger_->msg(Arc::DEBUG, "Request:\n%s", xml);
102
100
 
103
101
    Arc::PayloadSOAP *response = NULL;
104
102
    Arc::MCC_Status status = client->process(&request, &response);
105
103
 
106
104
    if (!status) {
107
 
      logger_->msg(Arc::ERROR, "DTR %s: Could not connect to service %s: %s",
108
 
                   dtr_id, endpoint.str(), (std::string)status);
 
105
      logger_->msg(Arc::ERROR, "Could not connect to service %s: %s",
 
106
                   endpoint.str(), (std::string)status);
109
107
      if (response)
110
108
        delete response;
111
109
      return;
112
110
    }
113
111
 
114
112
    if (!response) {
115
 
      logger_->msg(Arc::ERROR, "DTR %s: No SOAP response from Delivery service %s",
116
 
                   dtr_id, endpoint.str());
 
113
      logger_->msg(Arc::ERROR, "No SOAP response from Delivery service %s", endpoint.str());
117
114
      return;
118
115
    }
119
116
 
120
117
    response->GetXML(xml, true);
121
 
    logger_->msg(Arc::DEBUG, "DTR %s: Response:\n%s", dtr_id, xml);
 
118
    logger_->msg(Arc::DEBUG, "Response:\n%s", xml);
122
119
 
123
120
    if (response->IsFault()) {
124
121
      Arc::SOAPFault& fault = *response->Fault();
127
124
        if (fault.Reason(n).empty()) break;
128
125
        err += ": " + fault.Reason(n);
129
126
      }
130
 
      logger_->msg(Arc::ERROR, "DTR %s: Failed to start transfer request: %s", dtr_id, err);
 
127
      logger_->msg(Arc::ERROR, "Failed to start transfer request: %s", err);
131
128
      delete response;
132
129
      return;
133
130
    }
134
131
 
135
132
    Arc::XMLNode resultnode = (*response)["DataDeliveryStartResponse"]["DataDeliveryStartResult"]["Result"][0];
136
133
    if (!resultnode || !resultnode["ResultCode"]) {
137
 
      logger_->msg(Arc::ERROR, "DTR %s: Bad format in XML response from service at %s: %s",
138
 
                   dtr_id, endpoint.str(), xml);
 
134
      logger_->msg(Arc::ERROR, "Bad format in XML response from service at %s: %s",
 
135
                   endpoint.str(), xml);
139
136
      delete response;
140
137
      return;
141
138
    }
142
139
 
143
140
    std::string resultcode = (std::string)(resultnode["ResultCode"]);
144
141
    if (resultcode != "OK") {
145
 
      logger_->msg(Arc::ERROR, "DTR %s: Could not make new transfer request: %s: %s",
146
 
                   dtr_id, resultcode, (std::string)(resultnode[0]["ErrorDescription"]));
 
142
      logger_->msg(Arc::ERROR, "Could not make new transfer request: %s: %s",
 
143
                   resultcode, (std::string)(resultnode[0]["ErrorDescription"]));
147
144
      delete response;
148
145
      return;
149
146
    }
150
 
    logger_->msg(Arc::INFO, "DTR %s: Started remote Delivery at %s",
151
 
                 dtr_id, endpoint.str());
 
147
    logger_->msg(Arc::INFO, "Started remote Delivery at %s", endpoint.str());
152
148
 
153
149
    delete response;
154
150
    valid = true;
174
170
 
175
171
    std::string xml;
176
172
    request.GetXML(xml, true);
177
 
    logger_->msg(Arc::DEBUG, "DTR %s: Request:\n%s", dtr_id, xml);
 
173
    logger_->msg(Arc::DEBUG, "Request:\n%s", xml);
178
174
 
179
175
    Arc::PayloadSOAP *response = NULL;
180
176
 
181
177
    Arc::MCC_Status status = client->process(&request, &response);
182
178
 
183
179
    if (!status) {
184
 
      logger_->msg(Arc::ERROR, "DTR %s: Failed to send cancel request: %s", dtr_id, (std::string)status);
 
180
      logger_->msg(Arc::ERROR, "Failed to send cancel request: %s", (std::string)status);
185
181
      if (response)
186
182
        delete response;
187
183
      return;
188
184
    }
189
185
 
190
186
    if (!response) {
191
 
      logger_->msg(Arc::ERROR, "DTR %s: Failed to cancel: No SOAP response", dtr_id);
 
187
      logger_->msg(Arc::ERROR, "Failed to cancel: No SOAP response");
192
188
      return;
193
189
    }
194
190
 
195
191
    response->GetXML(xml, true);
196
 
    logger_->msg(Arc::DEBUG, "DTR %s: Response:\n%s", dtr_id, xml);
 
192
    logger_->msg(Arc::DEBUG, "Response:\n%s", xml);
197
193
 
198
194
    if (response->IsFault()) {
199
195
      Arc::SOAPFault& fault = *response->Fault();
202
198
        if (fault.Reason(n).empty()) break;
203
199
        err += ": " + fault.Reason(n);
204
200
      }
205
 
      logger_->msg(Arc::ERROR, "DTR %s: Failed to cancel transfer request: %s", dtr_id, err);
 
201
      logger_->msg(Arc::ERROR, "Failed to cancel transfer request: %s", err);
206
202
      delete response;
207
203
      return;
208
204
    }
209
205
 
210
206
    Arc::XMLNode resultnode = (*response)["DataDeliveryCancelResponse"]["DataDeliveryCancelResult"]["Result"][0];
211
207
    if (!resultnode || !resultnode["ResultCode"]) {
212
 
      logger_->msg(Arc::ERROR, "DTR %s: Bad format in XML response: %s", dtr_id, xml);
 
208
      logger_->msg(Arc::ERROR, "Bad format in XML response: %s", xml);
213
209
      delete response;
214
210
      return;
215
211
    }
216
212
 
217
213
    if ((std::string)resultnode["ResultCode"] != "OK") {
218
214
      Arc::XMLNode errnode = resultnode["ErrorDescription"];
219
 
      logger_->msg(Arc::ERROR, "DTR %s: Failed to cancel: %s", dtr_id, (std::string)errnode);
 
215
      logger_->msg(Arc::ERROR, "Failed to cancel: %s", (std::string)errnode);
220
216
    }
221
217
    delete response;
222
218
  }
239
235
 
240
236
    std::string xml;
241
237
    request.GetXML(xml, true);
242
 
    logger_->msg(Arc::DEBUG, "DTR %s: Request:\n%s", dtr_id, xml);
 
238
    logger_->msg(Arc::DEBUG, "Request:\n%s", xml);
243
239
 
244
240
    Arc::PayloadSOAP *response = NULL;
245
241
 
246
242
    Arc::MCC_Status status = client->process(&request, &response);
247
243
 
248
244
    if (!status) {
249
 
      logger_->msg(Arc::ERROR, "DTR %s: %s", dtr_id, (std::string)status);
 
245
      logger_->msg(Arc::ERROR, "%s", (std::string)status);
250
246
      status_.commstatus = CommFailed;
251
247
      if (response)
252
248
        delete response;
259
255
        HandleQueryFault("No SOAP response from delivery service");
260
256
        return;
261
257
      }
262
 
      logger_->msg(Arc::ERROR, "DTR %s: No SOAP response from delivery service", dtr_id);
 
258
      logger_->msg(Arc::ERROR, "No SOAP response from delivery service");
263
259
      status_.commstatus = CommFailed;
264
260
      valid = false;
265
261
      return;
266
262
    }
267
263
 
268
264
    response->GetXML(xml, true);
269
 
    logger_->msg(Arc::DEBUG, "DTR %s: Response:\n%s", dtr_id, xml);
 
265
    logger_->msg(Arc::DEBUG, "Response:\n%s", xml);
270
266
 
271
267
    if (response->IsFault()) {
272
268
      Arc::SOAPFault& fault = *response->Fault();
280
276
        HandleQueryFault("Failed to query state: " + err);
281
277
        return;
282
278
      }
283
 
      logger_->msg(Arc::ERROR, "DTR %s: Failed to query state: %s", dtr_id, err);
 
279
      logger_->msg(Arc::ERROR, "Failed to query state: %s", err);
284
280
      status_.commstatus = CommFailed;
285
281
      strncpy(status_.error_desc, "SOAP error in connection with delivery service", sizeof(status_.error_desc));
286
282
      valid = false;
289
285
 
290
286
    Arc::XMLNode resultnode = (*response)["DataDeliveryQueryResponse"]["DataDeliveryQueryResult"]["Result"][0];
291
287
    if (!resultnode || !resultnode["ResultCode"]) {
292
 
      logger_->msg(Arc::ERROR, "DTR %s: Bad format in XML response: %s", dtr_id, xml);
 
288
      logger_->msg(Arc::ERROR, "Bad format in XML response: %s", xml);
293
289
      delete response;
294
290
      status_.commstatus = CommFailed;
295
291
      valid = false;
314
310
      dtr->get_usercfg().ApplyToConfig(cfg);
315
311
    }
316
312
 
317
 
    dtr->get_logger()->msg(Arc::VERBOSE, "DTR %s: Connecting to Delivery service at %s",
318
 
                           dtr->get_short_id(), dtr->get_delivery_endpoint().str());
 
313
    dtr->get_logger()->msg(Arc::VERBOSE, "Connecting to Delivery service at %s",
 
314
                           dtr->get_delivery_endpoint().str());
319
315
    Arc::ClientSOAP client(cfg, dtr->get_delivery_endpoint(), dtr->get_usercfg().Timeout());
320
316
 
321
317
    Arc::NS ns;
325
321
 
326
322
    std::string xml;
327
323
    request.GetXML(xml, true);
328
 
    dtr->get_logger()->msg(Arc::DEBUG, "DTR %s: Request:\n%s", dtr->get_short_id(), xml);
 
324
    dtr->get_logger()->msg(Arc::DEBUG, "Request:\n%s", xml);
329
325
 
330
326
    Arc::PayloadSOAP *response = NULL;
331
327
    Arc::MCC_Status status = client.process(&request, &response);
332
328
 
333
329
    if (!status) {
334
 
      dtr->get_logger()->msg(Arc::ERROR, "DTR %s: Could not connect to service %s: %s",
335
 
                             dtr->get_short_id(), dtr->get_delivery_endpoint().str(), (std::string)status);
 
330
      dtr->get_logger()->msg(Arc::ERROR, "Could not connect to service %s: %s",
 
331
                             dtr->get_delivery_endpoint().str(), (std::string)status);
336
332
      if (response)
337
333
        delete response;
338
334
      return false;
339
335
    }
340
336
 
341
337
    if (!response) {
342
 
      dtr->get_logger()->msg(Arc::ERROR, "DTR %s: No SOAP response from Delivery service %s",
343
 
                             dtr->get_short_id(), dtr->get_delivery_endpoint().str());
 
338
      dtr->get_logger()->msg(Arc::ERROR, "No SOAP response from Delivery service %s",
 
339
                             dtr->get_delivery_endpoint().str());
344
340
      return false;
345
341
    }
346
342
 
347
343
    response->GetXML(xml, true);
348
 
    dtr->get_logger()->msg(Arc::DEBUG, "DTR %s: Response:\n%s", dtr->get_short_id(), xml);
 
344
    dtr->get_logger()->msg(Arc::DEBUG, "Response:\n%s", xml);
349
345
 
350
346
    if (response->IsFault()) {
351
347
      Arc::SOAPFault& fault = *response->Fault();
354
350
        if (fault.Reason(n).empty()) break;
355
351
        err += ": " + fault.Reason(n);
356
352
      }
357
 
      dtr->get_logger()->msg(Arc::ERROR, "DTR %s: SOAP fault from delivery service at %s: %s",
358
 
                             dtr->get_short_id(), dtr->get_delivery_endpoint().str(), err);
 
353
      dtr->get_logger()->msg(Arc::ERROR, "SOAP fault from delivery service at %s: %s",
 
354
                             dtr->get_delivery_endpoint().str(), err);
359
355
      delete response;
360
356
      return false;
361
357
    }
362
358
 
363
359
    Arc::XMLNode resultnode = (*response)["DataDeliveryPingResponse"]["DataDeliveryPingResult"]["Result"][0];
364
360
    if (!resultnode || !resultnode["ResultCode"]) {
365
 
      dtr->get_logger()->msg(Arc::ERROR, "DTR %s: Bad format in XML response from delivery service at %s: %s",
366
 
                             dtr->get_short_id(), dtr->get_delivery_endpoint().str(), xml);
 
361
      dtr->get_logger()->msg(Arc::ERROR, "Bad format in XML response from delivery service at %s: %s",
 
362
                             dtr->get_delivery_endpoint().str(), xml);
367
363
      delete response;
368
364
      return false;
369
365
    }
370
366
 
371
367
    std::string resultcode = (std::string)(resultnode["ResultCode"]);
372
368
    if (resultcode != "OK") {
373
 
      dtr->get_logger()->msg(Arc::ERROR, "DTR %s: Error pinging delivery service at %s: %s: %s",
374
 
                             dtr->get_short_id(), dtr->get_delivery_endpoint().str(),
 
369
      dtr->get_logger()->msg(Arc::ERROR, "Error pinging delivery service at %s: %s: %s",
 
370
                             dtr->get_delivery_endpoint().str(),
375
371
                             resultcode, (std::string)(resultnode[0]["ErrorDescription"]));
376
372
      delete response;
377
373
      return false;
459
455
      std::string log = (std::string)node["Log"];
460
456
      if (!log.empty()) {
461
457
        if (log.size() > 2000) log = log.substr(log.find('\n', log.size()-2000));
462
 
        logger_->msg(Arc::INFO, "DTR %s: DataDelivery log tail:\n%s", dtr_id, log);
 
458
        logger_->msg(Arc::INFO, "DataDelivery log tail:\n%s", log);
463
459
      }
464
460
      valid = false;
465
461
    }
469
465
  bool DataDeliveryRemoteComm::SetupDelegation(Arc::XMLNode& op, const Arc::UserConfig& usercfg) {
470
466
    const std::string& cert = (!usercfg.ProxyPath().empty() ? usercfg.ProxyPath() : usercfg.CertificatePath());
471
467
    const std::string& key  = (!usercfg.ProxyPath().empty() ? usercfg.ProxyPath() : usercfg.KeyPath());
 
468
    const std::string& credentials = usercfg.CredentialString();
472
469
 
473
 
    if (key.empty() || cert.empty()) {
474
 
      logger_->msg(Arc::VERBOSE, "DTR %s: Failed locating credentials", dtr_id);
 
470
    if (credentials.empty() && (key.empty() || cert.empty())) {
 
471
      logger_->msg(Arc::VERBOSE, "Failed locating credentials");
475
472
      return false;
476
473
    }
477
474
 
478
475
    if(!client->Load()) {
479
 
      logger_->msg(Arc::VERBOSE, "DTR %s: Failed to initiate client connection", dtr_id);
 
476
      logger_->msg(Arc::VERBOSE, "Failed to initiate client connection");
480
477
      return false;
481
478
    }
482
479
 
483
480
    Arc::MCC* entry = client->GetEntry();
484
481
    if(!entry) {
485
 
      logger_->msg(Arc::VERBOSE, "DTR %s: Client connection has no entry point", dtr_id);
 
482
      logger_->msg(Arc::VERBOSE, "Client connection has no entry point");
486
483
      return false;
487
484
    }
488
485
 
489
 
    Arc::DelegationProviderSOAP deleg(cert, key);
490
 
    logger_->msg(Arc::VERBOSE, "DTR %s: Initiating delegation procedure", dtr_id);
491
 
    if (!deleg.DelegateCredentialsInit(*entry, &(client->GetContext()))) {
492
 
      logger_->msg(Arc::VERBOSE, "DTR %s: Failed to initiate delegation credentials", dtr_id);
 
486
    Arc::DelegationProviderSOAP * deleg = NULL;
 
487
    // Use in-memory credentials if set in UserConfig
 
488
    if (!credentials.empty()) deleg = new Arc::DelegationProviderSOAP(credentials);
 
489
    else deleg = new Arc::DelegationProviderSOAP(cert, key);
 
490
    logger_->msg(Arc::VERBOSE, "Initiating delegation procedure");
 
491
    if (!deleg->DelegateCredentialsInit(*entry, &(client->GetContext()))) {
 
492
      logger_->msg(Arc::VERBOSE, "Failed to initiate delegation credentials");
 
493
      delete deleg;
493
494
      return false;
494
495
    }
495
 
    deleg.DelegatedToken(op);
 
496
    deleg->DelegatedToken(op);
 
497
    delete deleg;
496
498
    return true;
497
499
  }
498
500
 
499
501
  void DataDeliveryRemoteComm::HandleQueryFault(const std::string& err) {
500
502
    // Just return without changing status
501
 
    logger_->msg(Arc::WARNING, "DTR %s: %s", dtr_id, err);
 
503
    logger_->msg(Arc::WARNING, err);
502
504
    status_.timestamp = time(NULL);
503
505
    // A reconnect may be needed after losing connection
504
506
    delete client;