Class: Airavata::Processor

Inherits:

BaseAPI::Processor

Object
BaseAPI::Processor
Airavata::Processor

show all

Includes:: Thrift::Processor

Defined in:: lib/airavata.rb

Instance Method Summary collapse

Methods inherited from BaseAPI::Processor

#process_getAPIVersion

Instance Method Details

#process_addCloudJobSubmissionDetails(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5188

def process_addCloudJobSubmissionDetails(seqid, iprot, oprot)
  args = read_args(iprot, AddCloudJobSubmissionDetails_args)
  result = AddCloudJobSubmissionDetails_result.new()
  begin
    result.success = @handler.addCloudJobSubmissionDetails(args.authzToken, args.computeResourceId, args.priorityOrder, args.cloudSubmission)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'addCloudJobSubmissionDetails', seqid)
end

#process_addGateway(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3670

def process_addGateway(seqid, iprot, oprot)
  args = read_args(iprot, AddGateway_args)
  result = AddGateway_result.new()
  begin
    result.success = @handler.addGateway(args.authzToken, args.gateway)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'addGateway', seqid)
end

#process_addGatewayComputeResourcePreference(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5732

def process_addGatewayComputeResourcePreference(seqid, iprot, oprot)
  args = read_args(iprot, AddGatewayComputeResourcePreference_args)
  result = AddGatewayComputeResourcePreference_result.new()
  begin
    result.success = @handler.addGatewayComputeResourcePreference(args.authzToken, args.gatewayID, args.computeResourceId, args.computeResourcePreference)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'addGatewayComputeResourcePreference', seqid)
end

#process_addGatewayStoragePreference(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5749

def process_addGatewayStoragePreference(seqid, iprot, oprot)
  args = read_args(iprot, AddGatewayStoragePreference_args)
  result = AddGatewayStoragePreference_result.new()
  begin
    result.success = @handler.addGatewayStoragePreference(args.authzToken, args.gatewayID, args.storageResourceId, args.storagePreference)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'addGatewayStoragePreference', seqid)
end

#process_addGridFTPDataMovementDetails(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5426

def process_addGridFTPDataMovementDetails(seqid, iprot, oprot)
  args = read_args(iprot, AddGridFTPDataMovementDetails_args)
  result = AddGridFTPDataMovementDetails_result.new()
  begin
    result.success = @handler.addGridFTPDataMovementDetails(args.authzToken, args.productUri, args.dataMoveType, args.priorityOrder, args.gridFTPDataMovement)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'addGridFTPDataMovementDetails', seqid)
end

#process_addLocalDataMovementDetails(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5273

def process_addLocalDataMovementDetails(seqid, iprot, oprot)
  args = read_args(iprot, AddLocalDataMovementDetails_args)
  result = AddLocalDataMovementDetails_result.new()
  begin
    result.success = @handler.addLocalDataMovementDetails(args.authzToken, args.productUri, args.dataMoveType, args.priorityOrder, args.localDataMovement)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'addLocalDataMovementDetails', seqid)
end

#process_addLocalSubmissionDetails(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5052

def process_addLocalSubmissionDetails(seqid, iprot, oprot)
  args = read_args(iprot, AddLocalSubmissionDetails_args)
  result = AddLocalSubmissionDetails_result.new()
  begin
    result.success = @handler.addLocalSubmissionDetails(args.authzToken, args.computeResourceId, args.priorityOrder, args.localSubmission)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'addLocalSubmissionDetails', seqid)
end

#process_addSCPDataMovementDetails(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5324

def process_addSCPDataMovementDetails(seqid, iprot, oprot)
  args = read_args(iprot, AddSCPDataMovementDetails_args)
  result = AddSCPDataMovementDetails_result.new()
  begin
    result.success = @handler.addSCPDataMovementDetails(args.authzToken, args.productUri, args.dataMoveType, args.priorityOrder, args.scpDataMovement)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'addSCPDataMovementDetails', seqid)
end

#process_addSSHForkJobSubmissionDetails(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5120

def process_addSSHForkJobSubmissionDetails(seqid, iprot, oprot)
  args = read_args(iprot, AddSSHForkJobSubmissionDetails_args)
  result = AddSSHForkJobSubmissionDetails_result.new()
  begin
    result.success = @handler.addSSHForkJobSubmissionDetails(args.authzToken, args.computeResourceId, args.priorityOrder, args.sshJobSubmission)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'addSSHForkJobSubmissionDetails', seqid)
end

#process_addSSHJobSubmissionDetails(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5103

def process_addSSHJobSubmissionDetails(seqid, iprot, oprot)
  args = read_args(iprot, AddSSHJobSubmissionDetails_args)
  result = AddSSHJobSubmissionDetails_result.new()
  begin
    result.success = @handler.addSSHJobSubmissionDetails(args.authzToken, args.computeResourceId, args.priorityOrder, args.sshJobSubmission)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'addSSHJobSubmissionDetails', seqid)
end

#process_addUnicoreDataMovementDetails(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5375

def process_addUnicoreDataMovementDetails(seqid, iprot, oprot)
  args = read_args(iprot, AddUnicoreDataMovementDetails_args)
  result = AddUnicoreDataMovementDetails_result.new()
  begin
    result.success = @handler.addUnicoreDataMovementDetails(args.authzToken, args.productUri, args.dataMoveType, args.priorityOrder, args.unicoreDataMovement)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'addUnicoreDataMovementDetails', seqid)
end

#process_addUNICOREJobSubmissionDetails(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5154

def process_addUNICOREJobSubmissionDetails(seqid, iprot, oprot)
  args = read_args(iprot, AddUNICOREJobSubmissionDetails_args)
  result = AddUNICOREJobSubmissionDetails_result.new()
  begin
    result.success = @handler.addUNICOREJobSubmissionDetails(args.authzToken, args.computeResourceId, args.priorityOrder, args.unicoreJobSubmission)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'addUNICOREJobSubmissionDetails', seqid)
end

#process_addUserComputeResourcePreference(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6072

def process_addUserComputeResourcePreference(seqid, iprot, oprot)
  args = read_args(iprot, AddUserComputeResourcePreference_args)
  result = AddUserComputeResourcePreference_result.new()
  begin
    result.success = @handler.addUserComputeResourcePreference(args.authzToken, args.userId, args.gatewayID, args.userComputeResourceId, args.userComputeResourcePreference)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'addUserComputeResourcePreference', seqid)
end

#process_addUserStoragePreference(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6089

def process_addUserStoragePreference(seqid, iprot, oprot)
  args = read_args(iprot, AddUserStoragePreference_args)
  result = AddUserStoragePreference_result.new()
  begin
    result.success = @handler.addUserStoragePreference(args.authzToken, args.userId, args.gatewayID, args.userStorageResourceId, args.userStoragePreference)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'addUserStoragePreference', seqid)
end

#process_changeDataMovementPriorities(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5528

def process_changeDataMovementPriorities(seqid, iprot, oprot)
  args = read_args(iprot, ChangeDataMovementPriorities_args)
  result = ChangeDataMovementPriorities_result.new()
  begin
    result.success = @handler.changeDataMovementPriorities(args.authzToken, args.dataMovementPriorityMap)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'changeDataMovementPriorities', seqid)
end

#process_changeDataMovementPriority(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5494

def process_changeDataMovementPriority(seqid, iprot, oprot)
  args = read_args(iprot, ChangeDataMovementPriority_args)
  result = ChangeDataMovementPriority_result.new()
  begin
    result.success = @handler.changeDataMovementPriority(args.authzToken, args.dataMovementInterfaceId, args.newPriorityOrder)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'changeDataMovementPriority', seqid)
end

#process_changeJobSubmissionPriorities(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5511

def process_changeJobSubmissionPriorities(seqid, iprot, oprot)
  args = read_args(iprot, ChangeJobSubmissionPriorities_args)
  result = ChangeJobSubmissionPriorities_result.new()
  begin
    result.success = @handler.changeJobSubmissionPriorities(args.authzToken, args.jobSubmissionPriorityMap)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'changeJobSubmissionPriorities', seqid)
end

#process_changeJobSubmissionPriority(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5477

def process_changeJobSubmissionPriority(seqid, iprot, oprot)
  args = read_args(iprot, ChangeJobSubmissionPriority_args)
  result = ChangeJobSubmissionPriority_result.new()
  begin
    result.success = @handler.changeJobSubmissionPriority(args.authzToken, args.jobSubmissionInterfaceId, args.newPriorityOrder)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'changeJobSubmissionPriority', seqid)
end

#process_cloneApplicationInterface(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4729

def process_cloneApplicationInterface(seqid, iprot, oprot)
  args = read_args(iprot, CloneApplicationInterface_args)
  result = CloneApplicationInterface_result.new()
  begin
    result.success = @handler.cloneApplicationInterface(args.authzToken, args.existingAppInterfaceID, args.newApplicationName, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'cloneApplicationInterface', seqid)
end

#process_cloneExperiment(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4413

def process_cloneExperiment(seqid, iprot, oprot)
  args = read_args(iprot, CloneExperiment_args)
  result = CloneExperiment_result.new()
  begin
    result.success = @handler.cloneExperiment(args.authzToken, args.existingExperimentID, args.newExperimentName, args.newExperimentProjectId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::ExperimentNotFoundException => enf
    result.enf = enf
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  rescue ::ProjectNotFoundException => pnfe
    result.pnfe = pnfe
  end
  write_result(result, oprot, 'cloneExperiment', seqid)
end

#process_cloneExperimentByAdmin(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4434

def process_cloneExperimentByAdmin(seqid, iprot, oprot)
  args = read_args(iprot, CloneExperimentByAdmin_args)
  result = CloneExperimentByAdmin_result.new()
  begin
    result.success = @handler.cloneExperimentByAdmin(args.authzToken, args.existingExperimentID, args.newExperimentName, args.newExperimentProjectId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::ExperimentNotFoundException => enf
    result.enf = enf
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  rescue ::ProjectNotFoundException => pnfe
    result.pnfe = pnfe
  end
  write_result(result, oprot, 'cloneExperimentByAdmin', seqid)
end

#process_createExperiment(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4148

def process_createExperiment(seqid, iprot, oprot)
  args = read_args(iprot, CreateExperiment_args)
  result = CreateExperiment_result.new()
  begin
    result.success = @handler.createExperiment(args.authzToken, args.gatewayId, args.experiment)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'createExperiment', seqid)
end

#process_createGroupResourceProfile(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6514

def process_createGroupResourceProfile(seqid, iprot, oprot)
  args = read_args(iprot, CreateGroupResourceProfile_args)
  result = CreateGroupResourceProfile_result.new()
  begin
    result.success = @handler.createGroupResourceProfile(args.authzToken, args.groupResourceProfile)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'createGroupResourceProfile', seqid)
end

#process_createNotification(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3789

def process_createNotification(seqid, iprot, oprot)
  args = read_args(iprot, CreateNotification_args)
  result = CreateNotification_result.new()
  begin
    result.success = @handler.createNotification(args.authzToken, args.notification)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'createNotification', seqid)
end

#process_createProject(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3970

def process_createProject(seqid, iprot, oprot)
  args = read_args(iprot, CreateProject_args)
  result = CreateProject_result.new()
  begin
    result.success = @handler.createProject(args.authzToken, args.gatewayId, args.project)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'createProject', seqid)
end

#process_deleteApplicationDeployment(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4627

def process_deleteApplicationDeployment(seqid, iprot, oprot)
  args = read_args(iprot, DeleteApplicationDeployment_args)
  result = DeleteApplicationDeployment_result.new()
  begin
    result.success = @handler.deleteApplicationDeployment(args.authzToken, args.appDeploymentId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deleteApplicationDeployment', seqid)
end

#process_deleteApplicationInterface(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4780

def process_deleteApplicationInterface(seqid, iprot, oprot)
  args = read_args(iprot, DeleteApplicationInterface_args)
  result = DeleteApplicationInterface_result.new()
  begin
    result.success = @handler.deleteApplicationInterface(args.authzToken, args.appInterfaceId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deleteApplicationInterface', seqid)
end

#process_deleteApplicationModule(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4559

def process_deleteApplicationModule(seqid, iprot, oprot)
  args = read_args(iprot, DeleteApplicationModule_args)
  result = DeleteApplicationModule_result.new()
  begin
    result.success = @handler.deleteApplicationModule(args.authzToken, args.appModuleId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deleteApplicationModule', seqid)
end

#process_deleteBatchQueue(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5647

def process_deleteBatchQueue(seqid, iprot, oprot)
  args = read_args(iprot, DeleteBatchQueue_args)
  result = DeleteBatchQueue_result.new()
  begin
    result.success = @handler.deleteBatchQueue(args.authzToken, args.computeResourceId, args.queueName)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deleteBatchQueue', seqid)
end

#process_deleteComputeResource(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4950

def process_deleteComputeResource(seqid, iprot, oprot)
  args = read_args(iprot, DeleteComputeResource_args)
  result = DeleteComputeResource_result.new()
  begin
    result.success = @handler.deleteComputeResource(args.authzToken, args.computeResourceId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deleteComputeResource', seqid)
end

#process_deleteDataMovementInterface(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5562

def process_deleteDataMovementInterface(seqid, iprot, oprot)
  args = read_args(iprot, DeleteDataMovementInterface_args)
  result = DeleteDataMovementInterface_result.new()
  begin
    result.success = @handler.deleteDataMovementInterface(args.authzToken, args.productUri, args.dataMovementInterfaceId, args.dataMoveType)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deleteDataMovementInterface', seqid)
end

#process_deleteExperiment(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4165

def process_deleteExperiment(seqid, iprot, oprot)
  args = read_args(iprot, DeleteExperiment_args)
  result = DeleteExperiment_result.new()
  begin
    result.success = @handler.deleteExperiment(args.authzToken, args.experimentId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deleteExperiment', seqid)
end

#process_deleteGateway(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3738

def process_deleteGateway(seqid, iprot, oprot)
  args = read_args(iprot, DeleteGateway_args)
  result = DeleteGateway_result.new()
  begin
    result.success = @handler.deleteGateway(args.authzToken, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deleteGateway', seqid)
end

#process_deleteGatewayComputeResourcePreference(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5885

def process_deleteGatewayComputeResourcePreference(seqid, iprot, oprot)
  args = read_args(iprot, DeleteGatewayComputeResourcePreference_args)
  result = DeleteGatewayComputeResourcePreference_result.new()
  begin
    result.success = @handler.deleteGatewayComputeResourcePreference(args.authzToken, args.gatewayID, args.computeResourceId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deleteGatewayComputeResourcePreference', seqid)
end

#process_deleteGatewayResourceProfile(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5715

def process_deleteGatewayResourceProfile(seqid, iprot, oprot)
  args = read_args(iprot, DeleteGatewayResourceProfile_args)
  result = DeleteGatewayResourceProfile_result.new()
  begin
    result.success = @handler.deleteGatewayResourceProfile(args.authzToken, args.gatewayID)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deleteGatewayResourceProfile', seqid)
end

#process_deleteGatewayStoragePreference(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5902

def process_deleteGatewayStoragePreference(seqid, iprot, oprot)
  args = read_args(iprot, DeleteGatewayStoragePreference_args)
  result = DeleteGatewayStoragePreference_result.new()
  begin
    result.success = @handler.deleteGatewayStoragePreference(args.authzToken, args.gatewayID, args.storageId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deleteGatewayStoragePreference', seqid)
end

#process_deleteJobSubmissionInterface(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5545

def process_deleteJobSubmissionInterface(seqid, iprot, oprot)
  args = read_args(iprot, DeleteJobSubmissionInterface_args)
  result = DeleteJobSubmissionInterface_result.new()
  begin
    result.success = @handler.deleteJobSubmissionInterface(args.authzToken, args.computeResourceId, args.jobSubmissionInterfaceId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deleteJobSubmissionInterface', seqid)
end

#process_deleteNotification(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3823

def process_deleteNotification(seqid, iprot, oprot)
  args = read_args(iprot, DeleteNotification_args)
  result = DeleteNotification_result.new()
  begin
    result.success = @handler.deleteNotification(args.authzToken, args.gatewayId, args.notificationId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deleteNotification', seqid)
end

#process_deleteProject(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4025

def process_deleteProject(seqid, iprot, oprot)
  args = read_args(iprot, DeleteProject_args)
  result = DeleteProject_result.new()
  begin
    result.success = @handler.deleteProject(args.authzToken, args.projectId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::ProjectNotFoundException => pnfe
    result.pnfe = pnfe
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deleteProject', seqid)
end

#process_deletePWDCredential(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3953

def process_deletePWDCredential(seqid, iprot, oprot)
  args = read_args(iprot, DeletePWDCredential_args)
  result = DeletePWDCredential_result.new()
  begin
    result.success = @handler.deletePWDCredential(args.authzToken, args.airavataCredStoreToken)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deletePWDCredential', seqid)
end

#process_deleteResourceJobManager(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5630

def process_deleteResourceJobManager(seqid, iprot, oprot)
  args = read_args(iprot, DeleteResourceJobManager_args)
  result = DeleteResourceJobManager_result.new()
  begin
    result.success = @handler.deleteResourceJobManager(args.authzToken, args.resourceJobManagerId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deleteResourceJobManager', seqid)
end

#process_deleteSSHPubKey(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3936

def process_deleteSSHPubKey(seqid, iprot, oprot)
  args = read_args(iprot, DeleteSSHPubKey_args)
  result = DeleteSSHPubKey_result.new()
  begin
    result.success = @handler.deleteSSHPubKey(args.authzToken, args.airavataCredStoreToken)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deleteSSHPubKey', seqid)
end

#process_deleteStorageResource(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5035

def process_deleteStorageResource(seqid, iprot, oprot)
  args = read_args(iprot, DeleteStorageResource_args)
  result = DeleteStorageResource_result.new()
  begin
    result.success = @handler.deleteStorageResource(args.authzToken, args.storageResourceId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deleteStorageResource', seqid)
end

#process_deleteUserComputeResourcePreference(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6225

def process_deleteUserComputeResourcePreference(seqid, iprot, oprot)
  args = read_args(iprot, DeleteUserComputeResourcePreference_args)
  result = DeleteUserComputeResourcePreference_result.new()
  begin
    result.success = @handler.deleteUserComputeResourcePreference(args.authzToken, args.userId, args.gatewayID, args.userComputeResourceId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deleteUserComputeResourcePreference', seqid)
end

#process_deleteUserResourceProfile(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6055

def process_deleteUserResourceProfile(seqid, iprot, oprot)
  args = read_args(iprot, DeleteUserResourceProfile_args)
  result = DeleteUserResourceProfile_result.new()
  begin
    result.success = @handler.deleteUserResourceProfile(args.authzToken, args.userId, args.gatewayID)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deleteUserResourceProfile', seqid)
end

#process_deleteUserStoragePreference(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6242

def process_deleteUserStoragePreference(seqid, iprot, oprot)
  args = read_args(iprot, DeleteUserStoragePreference_args)
  result = DeleteUserStoragePreference_result.new()
  begin
    result.success = @handler.deleteUserStoragePreference(args.authzToken, args.userId, args.gatewayID, args.userStorageId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'deleteUserStoragePreference', seqid)
end

#process_doesUserHaveSSHAccount(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5936

def process_doesUserHaveSSHAccount(seqid, iprot, oprot)
  args = read_args(iprot, DoesUserHaveSSHAccount_args)
  result = DoesUserHaveSSHAccount_result.new()
  begin
    result.success = @handler.doesUserHaveSSHAccount(args.authzToken, args.computeResourceId, args.userId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'doesUserHaveSSHAccount', seqid)
end

#process_generateAndRegisterSSHKeys(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3874

def process_generateAndRegisterSSHKeys(seqid, iprot, oprot)
  args = read_args(iprot, GenerateAndRegisterSSHKeys_args)
  result = GenerateAndRegisterSSHKeys_result.new()
  begin
    result.success = @handler.generateAndRegisterSSHKeys(args.authzToken, args.description)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  end
  write_result(result, oprot, 'generateAndRegisterSSHKeys', seqid)
end

#process_getAccessibleApplicationDeployments(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4661

def process_getAccessibleApplicationDeployments(seqid, iprot, oprot)
  args = read_args(iprot, GetAccessibleApplicationDeployments_args)
  result = GetAccessibleApplicationDeployments_result.new()
  begin
    result.success = @handler.getAccessibleApplicationDeployments(args.authzToken, args.gatewayId, args.permissionType)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAccessibleApplicationDeployments', seqid)
end

#process_getAccessibleAppModules(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4542

def process_getAccessibleAppModules(seqid, iprot, oprot)
  args = read_args(iprot, GetAccessibleAppModules_args)
  result = GetAccessibleAppModules_result.new()
  begin
    result.success = @handler.getAccessibleAppModules(args.authzToken, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAccessibleAppModules', seqid)
end

#process_getAllAccessibleGroups(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6446

def process_getAllAccessibleGroups(seqid, iprot, oprot)
  args = read_args(iprot, GetAllAccessibleGroups_args)
  result = GetAllAccessibleGroups_result.new()
  begin
    result.success = @handler.getAllAccessibleGroups(args.authzToken, args.resourceId, args.permissionType)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAllAccessibleGroups', seqid)
end

#process_getAllAccessibleUsers(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6429

def process_getAllAccessibleUsers(seqid, iprot, oprot)
  args = read_args(iprot, GetAllAccessibleUsers_args)
  result = GetAllAccessibleUsers_result.new()
  begin
    result.success = @handler.getAllAccessibleUsers(args.authzToken, args.resourceId, args.permissionType)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAllAccessibleUsers', seqid)
end

#process_getAllApplicationDeployments(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4644

def process_getAllApplicationDeployments(seqid, iprot, oprot)
  args = read_args(iprot, GetAllApplicationDeployments_args)
  result = GetAllApplicationDeployments_result.new()
  begin
    result.success = @handler.getAllApplicationDeployments(args.authzToken, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAllApplicationDeployments', seqid)
end

#process_getAllApplicationInterfaceNames(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4797

def process_getAllApplicationInterfaceNames(seqid, iprot, oprot)
  args = read_args(iprot, GetAllApplicationInterfaceNames_args)
  result = GetAllApplicationInterfaceNames_result.new()
  begin
    result.success = @handler.getAllApplicationInterfaceNames(args.authzToken, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAllApplicationInterfaceNames', seqid)
end

#process_getAllApplicationInterfaces(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4814

def process_getAllApplicationInterfaces(seqid, iprot, oprot)
  args = read_args(iprot, GetAllApplicationInterfaces_args)
  result = GetAllApplicationInterfaces_result.new()
  begin
    result.success = @handler.getAllApplicationInterfaces(args.authzToken, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAllApplicationInterfaces', seqid)
end

#process_getAllAppModules(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4525

def process_getAllAppModules(seqid, iprot, oprot)
  args = read_args(iprot, GetAllAppModules_args)
  result = GetAllAppModules_result.new()
  begin
    result.success = @handler.getAllAppModules(args.authzToken, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAllAppModules', seqid)
end

#process_getAllComputeResourceNames(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4916

def process_getAllComputeResourceNames(seqid, iprot, oprot)
  args = read_args(iprot, GetAllComputeResourceNames_args)
  result = GetAllComputeResourceNames_result.new()
  begin
    result.success = @handler.getAllComputeResourceNames(args.authzToken)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAllComputeResourceNames', seqid)
end

#process_getAllCredentialSummaries(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3921

def process_getAllCredentialSummaries(seqid, iprot, oprot)
  args = read_args(iprot, GetAllCredentialSummaries_args)
  result = GetAllCredentialSummaries_result.new()
  begin
    result.success = @handler.getAllCredentialSummaries(args.authzToken, args.type)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  end
  write_result(result, oprot, 'getAllCredentialSummaries', seqid)
end

#process_getAllDirectlyAccessibleGroups(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6480

def process_getAllDirectlyAccessibleGroups(seqid, iprot, oprot)
  args = read_args(iprot, GetAllDirectlyAccessibleGroups_args)
  result = GetAllDirectlyAccessibleGroups_result.new()
  begin
    result.success = @handler.getAllDirectlyAccessibleGroups(args.authzToken, args.resourceId, args.permissionType)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAllDirectlyAccessibleGroups', seqid)
end

#process_getAllDirectlyAccessibleUsers(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6463

def process_getAllDirectlyAccessibleUsers(seqid, iprot, oprot)
  args = read_args(iprot, GetAllDirectlyAccessibleUsers_args)
  result = GetAllDirectlyAccessibleUsers_result.new()
  begin
    result.success = @handler.getAllDirectlyAccessibleUsers(args.authzToken, args.resourceId, args.permissionType)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAllDirectlyAccessibleUsers', seqid)
end

#process_getAllGatewayComputeResourcePreferences(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5800

def process_getAllGatewayComputeResourcePreferences(seqid, iprot, oprot)
  args = read_args(iprot, GetAllGatewayComputeResourcePreferences_args)
  result = GetAllGatewayComputeResourcePreferences_result.new()
  begin
    result.success = @handler.getAllGatewayComputeResourcePreferences(args.authzToken, args.gatewayID)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAllGatewayComputeResourcePreferences', seqid)
end

#process_getAllGatewayResourceProfiles(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5834

def process_getAllGatewayResourceProfiles(seqid, iprot, oprot)
  args = read_args(iprot, GetAllGatewayResourceProfiles_args)
  result = GetAllGatewayResourceProfiles_result.new()
  begin
    result.success = @handler.getAllGatewayResourceProfiles(args.authzToken)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAllGatewayResourceProfiles', seqid)
end

#process_getAllGateways(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3755

def process_getAllGateways(seqid, iprot, oprot)
  args = read_args(iprot, GetAllGateways_args)
  result = GetAllGateways_result.new()
  begin
    result.success = @handler.getAllGateways(args.authzToken)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAllGateways', seqid)
end

#process_getAllGatewayStoragePreferences(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5817

def process_getAllGatewayStoragePreferences(seqid, iprot, oprot)
  args = read_args(iprot, GetAllGatewayStoragePreferences_args)
  result = GetAllGatewayStoragePreferences_result.new()
  begin
    result.success = @handler.getAllGatewayStoragePreferences(args.authzToken, args.gatewayID)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAllGatewayStoragePreferences', seqid)
end

#process_getAllNotifications(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3857

def process_getAllNotifications(seqid, iprot, oprot)
  args = read_args(iprot, GetAllNotifications_args)
  result = GetAllNotifications_result.new()
  begin
    result.success = @handler.getAllNotifications(args.authzToken, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAllNotifications', seqid)
end

#process_getAllStorageResourceNames(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5001

def process_getAllStorageResourceNames(seqid, iprot, oprot)
  args = read_args(iprot, GetAllStorageResourceNames_args)
  result = GetAllStorageResourceNames_result.new()
  begin
    result.success = @handler.getAllStorageResourceNames(args.authzToken)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAllStorageResourceNames', seqid)
end

#process_getAllUserComputeResourcePreferences(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6140

def process_getAllUserComputeResourcePreferences(seqid, iprot, oprot)
  args = read_args(iprot, GetAllUserComputeResourcePreferences_args)
  result = GetAllUserComputeResourcePreferences_result.new()
  begin
    result.success = @handler.getAllUserComputeResourcePreferences(args.authzToken, args.userId, args.gatewayID)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAllUserComputeResourcePreferences', seqid)
end

#process_getAllUserResourceProfiles(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6174

def process_getAllUserResourceProfiles(seqid, iprot, oprot)
  args = read_args(iprot, GetAllUserResourceProfiles_args)
  result = GetAllUserResourceProfiles_result.new()
  begin
    result.success = @handler.getAllUserResourceProfiles(args.authzToken)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAllUserResourceProfiles', seqid)
end

#process_getAllUsersInGateway(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3687

def process_getAllUsersInGateway(seqid, iprot, oprot)
  args = read_args(iprot, GetAllUsersInGateway_args)
  result = GetAllUsersInGateway_result.new()
  begin
    result.success = @handler.getAllUsersInGateway(args.authzToken, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAllUsersInGateway', seqid)
end

#process_getAllUserStoragePreferences(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6157

def process_getAllUserStoragePreferences(seqid, iprot, oprot)
  args = read_args(iprot, GetAllUserStoragePreferences_args)
  result = GetAllUserStoragePreferences_result.new()
  begin
    result.success = @handler.getAllUserStoragePreferences(args.authzToken, args.userId, args.gatewayID)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAllUserStoragePreferences', seqid)
end

#process_getApplicationDeployment(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4593

def process_getApplicationDeployment(seqid, iprot, oprot)
  args = read_args(iprot, GetApplicationDeployment_args)
  result = GetApplicationDeployment_result.new()
  begin
    result.success = @handler.getApplicationDeployment(args.authzToken, args.appDeploymentId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getApplicationDeployment', seqid)
end

#process_getApplicationDeploymentsForAppModuleAndGroupResourceProfile(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4695

def process_getApplicationDeploymentsForAppModuleAndGroupResourceProfile(seqid, iprot, oprot)
  args = read_args(iprot, GetApplicationDeploymentsForAppModuleAndGroupResourceProfile_args)
  result = GetApplicationDeploymentsForAppModuleAndGroupResourceProfile_result.new()
  begin
    result.success = @handler.getApplicationDeploymentsForAppModuleAndGroupResourceProfile(args.authzToken, args.appModuleId, args.groupResourceProfileId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getApplicationDeploymentsForAppModuleAndGroupResourceProfile', seqid)
end

#process_getApplicationInputs(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4831

def process_getApplicationInputs(seqid, iprot, oprot)
  args = read_args(iprot, GetApplicationInputs_args)
  result = GetApplicationInputs_result.new()
  begin
    result.success = @handler.getApplicationInputs(args.authzToken, args.appInterfaceId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getApplicationInputs', seqid)
end

#process_getApplicationInterface(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4746

def process_getApplicationInterface(seqid, iprot, oprot)
  args = read_args(iprot, GetApplicationInterface_args)
  result = GetApplicationInterface_result.new()
  begin
    result.success = @handler.getApplicationInterface(args.authzToken, args.appInterfaceId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getApplicationInterface', seqid)
end

#process_getApplicationModule(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4491

def process_getApplicationModule(seqid, iprot, oprot)
  args = read_args(iprot, GetApplicationModule_args)
  result = GetApplicationModule_result.new()
  begin
    result.success = @handler.getApplicationModule(args.authzToken, args.appModuleId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getApplicationModule', seqid)
end

#process_getApplicationOutputs(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4848

def process_getApplicationOutputs(seqid, iprot, oprot)
  args = read_args(iprot, GetApplicationOutputs_args)
  result = GetApplicationOutputs_result.new()
  begin
    result.success = @handler.getApplicationOutputs(args.authzToken, args.appInterfaceId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getApplicationOutputs', seqid)
end

#process_getAppModuleDeployedResources(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4678

def process_getAppModuleDeployedResources(seqid, iprot, oprot)
  args = read_args(iprot, GetAppModuleDeployedResources_args)
  result = GetAppModuleDeployedResources_result.new()
  begin
    result.success = @handler.getAppModuleDeployedResources(args.authzToken, args.appModuleId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAppModuleDeployedResources', seqid)
end

#process_getAvailableAppInterfaceComputeResources(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4865

def process_getAvailableAppInterfaceComputeResources(seqid, iprot, oprot)
  args = read_args(iprot, GetAvailableAppInterfaceComputeResources_args)
  result = GetAvailableAppInterfaceComputeResources_result.new()
  begin
    result.success = @handler.getAvailableAppInterfaceComputeResources(args.authzToken, args.appInterfaceId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getAvailableAppInterfaceComputeResources', seqid)
end

#process_getBatchQueueResourcePolicy(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6684

def process_getBatchQueueResourcePolicy(seqid, iprot, oprot)
  args = read_args(iprot, GetBatchQueueResourcePolicy_args)
  result = GetBatchQueueResourcePolicy_result.new()
  begin
    result.success = @handler.getBatchQueueResourcePolicy(args.authzToken, args.resourcePolicyId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getBatchQueueResourcePolicy', seqid)
end

#process_getChildDataProducts(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6344

def process_getChildDataProducts(seqid, iprot, oprot)
  args = read_args(iprot, GetChildDataProducts_args)
  result = GetChildDataProducts_result.new()
  begin
    result.success = @handler.getChildDataProducts(args.authzToken, args.productUri)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getChildDataProducts', seqid)
end

#process_getCloudJobSubmission(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5205

def process_getCloudJobSubmission(seqid, iprot, oprot)
  args = read_args(iprot, GetCloudJobSubmission_args)
  result = GetCloudJobSubmission_result.new()
  begin
    result.success = @handler.getCloudJobSubmission(args.authzToken, args.jobSubmissionId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getCloudJobSubmission', seqid)
end

#process_getComputeResource(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4899

def process_getComputeResource(seqid, iprot, oprot)
  args = read_args(iprot, GetComputeResource_args)
  result = GetComputeResource_result.new()
  begin
    result.success = @handler.getComputeResource(args.authzToken, args.computeResourceId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getComputeResource', seqid)
end

#process_getCredentialSummary(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3904

def process_getCredentialSummary(seqid, iprot, oprot)
  args = read_args(iprot, GetCredentialSummary_args)
  result = GetCredentialSummary_result.new()
  begin
    result.success = @handler.getCredentialSummary(args.authzToken, args.tokenId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getCredentialSummary', seqid)
end

#process_getDataProduct(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6293

def process_getDataProduct(seqid, iprot, oprot)
  args = read_args(iprot, GetDataProduct_args)
  result = GetDataProduct_result.new()
  begin
    result.success = @handler.getDataProduct(args.authzToken, args.dataProductUri)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getDataProduct', seqid)
end

#process_getDetailedExperimentTree(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4220

def process_getDetailedExperimentTree(seqid, iprot, oprot)
  args = read_args(iprot, GetDetailedExperimentTree_args)
  result = GetDetailedExperimentTree_result.new()
  begin
    result.success = @handler.getDetailedExperimentTree(args.authzToken, args.airavataExperimentId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::ExperimentNotFoundException => enf
    result.enf = enf
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getDetailedExperimentTree', seqid)
end

#process_getExperiment(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4182

def process_getExperiment(seqid, iprot, oprot)
  args = read_args(iprot, GetExperiment_args)
  result = GetExperiment_result.new()
  begin
    result.success = @handler.getExperiment(args.authzToken, args.airavataExperimentId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::ExperimentNotFoundException => enf
    result.enf = enf
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getExperiment', seqid)
end

#process_getExperimentByAdmin(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4201

def process_getExperimentByAdmin(seqid, iprot, oprot)
  args = read_args(iprot, GetExperimentByAdmin_args)
  result = GetExperimentByAdmin_result.new()
  begin
    result.success = @handler.getExperimentByAdmin(args.authzToken, args.airavataExperimentId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::ExperimentNotFoundException => enf
    result.enf = enf
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getExperimentByAdmin', seqid)
end

#process_getExperimentOutputs(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4337

def process_getExperimentOutputs(seqid, iprot, oprot)
  args = read_args(iprot, GetExperimentOutputs_args)
  result = GetExperimentOutputs_result.new()
  begin
    result.success = @handler.getExperimentOutputs(args.authzToken, args.airavataExperimentId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::ExperimentNotFoundException => enf
    result.enf = enf
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getExperimentOutputs', seqid)
end

#process_getExperimentsInProject(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4112

def process_getExperimentsInProject(seqid, iprot, oprot)
  args = read_args(iprot, GetExperimentsInProject_args)
  result = GetExperimentsInProject_result.new()
  begin
    result.success = @handler.getExperimentsInProject(args.authzToken, args.projectId, args.limit, args.offset)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::ProjectNotFoundException => pnfe
    result.pnfe = pnfe
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getExperimentsInProject', seqid)
end

#process_getExperimentStatistics(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4095

def process_getExperimentStatistics(seqid, iprot, oprot)
  args = read_args(iprot, GetExperimentStatistics_args)
  result = GetExperimentStatistics_result.new()
  begin
    result.success = @handler.getExperimentStatistics(args.authzToken, args.gatewayId, args.fromTime, args.toTime, args.userName, args.applicationName, args.resourceHostName)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getExperimentStatistics', seqid)
end

#process_getExperimentStatus(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4318

def process_getExperimentStatus(seqid, iprot, oprot)
  args = read_args(iprot, GetExperimentStatus_args)
  result = GetExperimentStatus_result.new()
  begin
    result.success = @handler.getExperimentStatus(args.authzToken, args.airavataExperimentId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::ExperimentNotFoundException => enf
    result.enf = enf
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getExperimentStatus', seqid)
end

#process_getGateway(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3721

def process_getGateway(seqid, iprot, oprot)
  args = read_args(iprot, GetGateway_args)
  result = GetGateway_result.new()
  begin
    result.success = @handler.getGateway(args.authzToken, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getGateway', seqid)
end

#process_getGatewayComputeResourcePreference(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5766

def process_getGatewayComputeResourcePreference(seqid, iprot, oprot)
  args = read_args(iprot, GetGatewayComputeResourcePreference_args)
  result = GetGatewayComputeResourcePreference_result.new()
  begin
    result.success = @handler.getGatewayComputeResourcePreference(args.authzToken, args.gatewayID, args.computeResourceId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getGatewayComputeResourcePreference', seqid)
end

#process_getGatewayGroups(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6752

def process_getGatewayGroups(seqid, iprot, oprot)
  args = read_args(iprot, GetGatewayGroups_args)
  result = GetGatewayGroups_result.new()
  begin
    result.success = @handler.getGatewayGroups(args.authzToken)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getGatewayGroups', seqid)
end

#process_getGatewayResourceProfile(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5681

def process_getGatewayResourceProfile(seqid, iprot, oprot)
  args = read_args(iprot, GetGatewayResourceProfile_args)
  result = GetGatewayResourceProfile_result.new()
  begin
    result.success = @handler.getGatewayResourceProfile(args.authzToken, args.gatewayID)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getGatewayResourceProfile', seqid)
end

#process_getGatewayStoragePreference(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5783

def process_getGatewayStoragePreference(seqid, iprot, oprot)
  args = read_args(iprot, GetGatewayStoragePreference_args)
  result = GetGatewayStoragePreference_result.new()
  begin
    result.success = @handler.getGatewayStoragePreference(args.authzToken, args.gatewayID, args.storageResourceId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getGatewayStoragePreference', seqid)
end

#process_getGridFTPDataMovement(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5460

def process_getGridFTPDataMovement(seqid, iprot, oprot)
  args = read_args(iprot, GetGridFTPDataMovement_args)
  result = GetGridFTPDataMovement_result.new()
  begin
    result.success = @handler.getGridFTPDataMovement(args.authzToken, args.dataMovementId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getGridFTPDataMovement', seqid)
end

#process_getGroupBatchQueueResourcePolicyList(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6718

def process_getGroupBatchQueueResourcePolicyList(seqid, iprot, oprot)
  args = read_args(iprot, GetGroupBatchQueueResourcePolicyList_args)
  result = GetGroupBatchQueueResourcePolicyList_result.new()
  begin
    result.success = @handler.getGroupBatchQueueResourcePolicyList(args.authzToken, args.groupResourceProfileId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getGroupBatchQueueResourcePolicyList', seqid)
end

#process_getGroupComputeResourcePolicy(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6667

def process_getGroupComputeResourcePolicy(seqid, iprot, oprot)
  args = read_args(iprot, GetGroupComputeResourcePolicy_args)
  result = GetGroupComputeResourcePolicy_result.new()
  begin
    result.success = @handler.getGroupComputeResourcePolicy(args.authzToken, args.resourcePolicyId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getGroupComputeResourcePolicy', seqid)
end

#process_getGroupComputeResourcePolicyList(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6735

def process_getGroupComputeResourcePolicyList(seqid, iprot, oprot)
  args = read_args(iprot, GetGroupComputeResourcePolicyList_args)
  result = GetGroupComputeResourcePolicyList_result.new()
  begin
    result.success = @handler.getGroupComputeResourcePolicyList(args.authzToken, args.groupResourceProfileId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getGroupComputeResourcePolicyList', seqid)
end

#process_getGroupComputeResourcePreference(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6650

def process_getGroupComputeResourcePreference(seqid, iprot, oprot)
  args = read_args(iprot, GetGroupComputeResourcePreference_args)
  result = GetGroupComputeResourcePreference_result.new()
  begin
    result.success = @handler.getGroupComputeResourcePreference(args.authzToken, args.computeResourceId, args.groupResourceProfileId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getGroupComputeResourcePreference', seqid)
end

#process_getGroupComputeResourcePrefList(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6701

def process_getGroupComputeResourcePrefList(seqid, iprot, oprot)
  args = read_args(iprot, GetGroupComputeResourcePrefList_args)
  result = GetGroupComputeResourcePrefList_result.new()
  begin
    result.success = @handler.getGroupComputeResourcePrefList(args.authzToken, args.groupResourceProfileId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getGroupComputeResourcePrefList', seqid)
end

#process_getGroupResourceList(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6582

def process_getGroupResourceList(seqid, iprot, oprot)
  args = read_args(iprot, GetGroupResourceList_args)
  result = GetGroupResourceList_result.new()
  begin
    result.success = @handler.getGroupResourceList(args.authzToken, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getGroupResourceList', seqid)
end

#process_getGroupResourceProfile(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6548

def process_getGroupResourceProfile(seqid, iprot, oprot)
  args = read_args(iprot, GetGroupResourceProfile_args)
  result = GetGroupResourceProfile_result.new()
  begin
    result.success = @handler.getGroupResourceProfile(args.authzToken, args.groupResourceProfileId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getGroupResourceProfile', seqid)
end

#process_getIntermediateOutputs(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4356

def process_getIntermediateOutputs(seqid, iprot, oprot)
  args = read_args(iprot, GetIntermediateOutputs_args)
  result = GetIntermediateOutputs_result.new()
  begin
    result.success = @handler.getIntermediateOutputs(args.authzToken, args.airavataExperimentId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::ExperimentNotFoundException => enf
    result.enf = enf
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getIntermediateOutputs', seqid)
end

#process_getJobDetails(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4394

def process_getJobDetails(seqid, iprot, oprot)
  args = read_args(iprot, GetJobDetails_args)
  result = GetJobDetails_result.new()
  begin
    result.success = @handler.getJobDetails(args.authzToken, args.airavataExperimentId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::ExperimentNotFoundException => enf
    result.enf = enf
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getJobDetails', seqid)
end

#process_getJobStatuses(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4375

def process_getJobStatuses(seqid, iprot, oprot)
  args = read_args(iprot, GetJobStatuses_args)
  result = GetJobStatuses_result.new()
  begin
    result.success = @handler.getJobStatuses(args.authzToken, args.airavataExperimentId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::ExperimentNotFoundException => enf
    result.enf = enf
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getJobStatuses', seqid)
end

#process_getLatestQueueStatuses(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6259

def process_getLatestQueueStatuses(seqid, iprot, oprot)
  args = read_args(iprot, GetLatestQueueStatuses_args)
  result = GetLatestQueueStatuses_result.new()
  begin
    result.success = @handler.getLatestQueueStatuses(args.authzToken)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getLatestQueueStatuses', seqid)
end

#process_getLocalDataMovement(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5307

def process_getLocalDataMovement(seqid, iprot, oprot)
  args = read_args(iprot, GetLocalDataMovement_args)
  result = GetLocalDataMovement_result.new()
  begin
    result.success = @handler.getLocalDataMovement(args.authzToken, args.dataMovementId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getLocalDataMovement', seqid)
end

#process_getLocalJobSubmission(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5086

def process_getLocalJobSubmission(seqid, iprot, oprot)
  args = read_args(iprot, GetLocalJobSubmission_args)
  result = GetLocalJobSubmission_result.new()
  begin
    result.success = @handler.getLocalJobSubmission(args.authzToken, args.jobSubmissionId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getLocalJobSubmission', seqid)
end

#process_getNotification(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3840

def process_getNotification(seqid, iprot, oprot)
  args = read_args(iprot, GetNotification_args)
  result = GetNotification_result.new()
  begin
    result.success = @handler.getNotification(args.authzToken, args.gatewayId, args.notificationId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getNotification', seqid)
end

#process_getParentDataProduct(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6327

def process_getParentDataProduct(seqid, iprot, oprot)
  args = read_args(iprot, GetParentDataProduct_args)
  result = GetParentDataProduct_result.new()
  begin
    result.success = @handler.getParentDataProduct(args.authzToken, args.productUri)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getParentDataProduct', seqid)
end

#process_getParser(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6769

def process_getParser(seqid, iprot, oprot)
  args = read_args(iprot, GetParser_args)
  result = GetParser_result.new()
  begin
    result.success = @handler.getParser(args.authzToken, args.parserId, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getParser', seqid)
end

#process_getParsingTemplate(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6837

def process_getParsingTemplate(seqid, iprot, oprot)
  args = read_args(iprot, GetParsingTemplate_args)
  result = GetParsingTemplate_result.new()
  begin
    result.success = @handler.getParsingTemplate(args.authzToken, args.templateId, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getParsingTemplate', seqid)
end

#process_getParsingTemplatesForExperiment(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6854

def process_getParsingTemplatesForExperiment(seqid, iprot, oprot)
  args = read_args(iprot, GetParsingTemplatesForExperiment_args)
  result = GetParsingTemplatesForExperiment_result.new()
  begin
    result.success = @handler.getParsingTemplatesForExperiment(args.authzToken, args.experimentId, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getParsingTemplatesForExperiment', seqid)
end

#process_getProject(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4006

def process_getProject(seqid, iprot, oprot)
  args = read_args(iprot, GetProject_args)
  result = GetProject_result.new()
  begin
    result.success = @handler.getProject(args.authzToken, args.projectId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::ProjectNotFoundException => pnfe
    result.pnfe = pnfe
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getProject', seqid)
end

#process_getResourceJobManager(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5613

def process_getResourceJobManager(seqid, iprot, oprot)
  args = read_args(iprot, GetResourceJobManager_args)
  result = GetResourceJobManager_result.new()
  begin
    result.success = @handler.getResourceJobManager(args.authzToken, args.resourceJobManagerId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getResourceJobManager', seqid)
end

#process_getSCPDataMovement(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5358

def process_getSCPDataMovement(seqid, iprot, oprot)
  args = read_args(iprot, GetSCPDataMovement_args)
  result = GetSCPDataMovement_result.new()
  begin
    result.success = @handler.getSCPDataMovement(args.authzToken, args.dataMovementId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getSCPDataMovement', seqid)
end

#process_getSSHAccountProvisioners(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5919

def process_getSSHAccountProvisioners(seqid, iprot, oprot)
  args = read_args(iprot, GetSSHAccountProvisioners_args)
  result = GetSSHAccountProvisioners_result.new()
  begin
    result.success = @handler.getSSHAccountProvisioners(args.authzToken)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getSSHAccountProvisioners', seqid)
end

#process_getSSHJobSubmission(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5137

def process_getSSHJobSubmission(seqid, iprot, oprot)
  args = read_args(iprot, GetSSHJobSubmission_args)
  result = GetSSHJobSubmission_result.new()
  begin
    result.success = @handler.getSSHJobSubmission(args.authzToken, args.jobSubmissionId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getSSHJobSubmission', seqid)
end

#process_getStorageResource(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4984

def process_getStorageResource(seqid, iprot, oprot)
  args = read_args(iprot, GetStorageResource_args)
  result = GetStorageResource_result.new()
  begin
    result.success = @handler.getStorageResource(args.authzToken, args.storageResourceId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getStorageResource', seqid)
end

#process_getUnicoreDataMovement(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5409

def process_getUnicoreDataMovement(seqid, iprot, oprot)
  args = read_args(iprot, GetUnicoreDataMovement_args)
  result = GetUnicoreDataMovement_result.new()
  begin
    result.success = @handler.getUnicoreDataMovement(args.authzToken, args.dataMovementId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getUnicoreDataMovement', seqid)
end

#process_getUnicoreJobSubmission(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5171

def process_getUnicoreJobSubmission(seqid, iprot, oprot)
  args = read_args(iprot, GetUnicoreJobSubmission_args)
  result = GetUnicoreJobSubmission_result.new()
  begin
    result.success = @handler.getUnicoreJobSubmission(args.authzToken, args.jobSubmissionId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getUnicoreJobSubmission', seqid)
end

#process_getUserComputeResourcePreference(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6106

def process_getUserComputeResourcePreference(seqid, iprot, oprot)
  args = read_args(iprot, GetUserComputeResourcePreference_args)
  result = GetUserComputeResourcePreference_result.new()
  begin
    result.success = @handler.getUserComputeResourcePreference(args.authzToken, args.userId, args.gatewayID, args.userComputeResourceId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getUserComputeResourcePreference', seqid)
end

#process_getUserExperiments(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4131

def process_getUserExperiments(seqid, iprot, oprot)
  args = read_args(iprot, GetUserExperiments_args)
  result = GetUserExperiments_result.new()
  begin
    result.success = @handler.getUserExperiments(args.authzToken, args.gatewayId, args.userName, args.limit, args.offset)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getUserExperiments', seqid)
end

#process_getUserProjects(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4044

def process_getUserProjects(seqid, iprot, oprot)
  args = read_args(iprot, GetUserProjects_args)
  result = GetUserProjects_result.new()
  begin
    result.success = @handler.getUserProjects(args.authzToken, args.gatewayId, args.userName, args.limit, args.offset)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getUserProjects', seqid)
end

#process_getUserResourceProfile(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6021

def process_getUserResourceProfile(seqid, iprot, oprot)
  args = read_args(iprot, GetUserResourceProfile_args)
  result = GetUserResourceProfile_result.new()
  begin
    result.success = @handler.getUserResourceProfile(args.authzToken, args.userId, args.gatewayID)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getUserResourceProfile', seqid)
end

#process_getUserStoragePreference(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6123

def process_getUserStoragePreference(seqid, iprot, oprot)
  args = read_args(iprot, GetUserStoragePreference_args)
  result = GetUserStoragePreference_result.new()
  begin
    result.success = @handler.getUserStoragePreference(args.authzToken, args.userId, args.gatewayID, args.userStorageResourceId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'getUserStoragePreference', seqid)
end

#process_isGatewayExist(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3772

def process_isGatewayExist(seqid, iprot, oprot)
  args = read_args(iprot, IsGatewayExist_args)
  result = IsGatewayExist_result.new()
  begin
    result.success = @handler.isGatewayExist(args.authzToken, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'isGatewayExist', seqid)
end

#process_isSSHSetupCompleteForUserComputeResourcePreference(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5953

def process_isSSHSetupCompleteForUserComputeResourcePreference(seqid, iprot, oprot)
  args = read_args(iprot, IsSSHSetupCompleteForUserComputeResourcePreference_args)
  result = IsSSHSetupCompleteForUserComputeResourcePreference_result.new()
  begin
    result.success = @handler.isSSHSetupCompleteForUserComputeResourcePreference(args.authzToken, args.computeResourceId, args.airavataCredStoreToken)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'isSSHSetupCompleteForUserComputeResourcePreference', seqid)
end

#process_isUserExists(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3653

def process_isUserExists(seqid, iprot, oprot)
  args = read_args(iprot, IsUserExists_args)
  result = IsUserExists_result.new()
  begin
    result.success = @handler.isUserExists(args.authzToken, args.gatewayId, args.userName)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'isUserExists', seqid)
end

#process_isUserResourceProfileExists(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6004

def process_isUserResourceProfileExists(seqid, iprot, oprot)
  args = read_args(iprot, IsUserResourceProfileExists_args)
  result = IsUserResourceProfileExists_result.new()
  begin
    result.success = @handler.isUserResourceProfileExists(args.authzToken, args.userId, args.gatewayID)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'isUserResourceProfileExists', seqid)
end

#process_launchExperiment(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4299

def process_launchExperiment(seqid, iprot, oprot)
  args = read_args(iprot, LaunchExperiment_args)
  result = LaunchExperiment_result.new()
  begin
    @handler.launchExperiment(args.authzToken, args.airavataExperimentId, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::ExperimentNotFoundException => enf
    result.enf = enf
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'launchExperiment', seqid)
end

#process_listAllParsers(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6803

def process_listAllParsers(seqid, iprot, oprot)
  args = read_args(iprot, ListAllParsers_args)
  result = ListAllParsers_result.new()
  begin
    result.success = @handler.listAllParsers(args.authzToken, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'listAllParsers', seqid)
end

#process_listAllParsingTemplates(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6905

def process_listAllParsingTemplates(seqid, iprot, oprot)
  args = read_args(iprot, ListAllParsingTemplates_args)
  result = ListAllParsingTemplates_result.new()
  begin
    result.success = @handler.listAllParsingTemplates(args.authzToken, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'listAllParsingTemplates', seqid)
end

#process_registerApplicationDeployment(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4576

def process_registerApplicationDeployment(seqid, iprot, oprot)
  args = read_args(iprot, RegisterApplicationDeployment_args)
  result = RegisterApplicationDeployment_result.new()
  begin
    result.success = @handler.registerApplicationDeployment(args.authzToken, args.gatewayId, args.applicationDeployment)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'registerApplicationDeployment', seqid)
end

#process_registerApplicationInterface(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4712

def process_registerApplicationInterface(seqid, iprot, oprot)
  args = read_args(iprot, RegisterApplicationInterface_args)
  result = RegisterApplicationInterface_result.new()
  begin
    result.success = @handler.registerApplicationInterface(args.authzToken, args.gatewayId, args.applicationInterface)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'registerApplicationInterface', seqid)
end

#process_registerApplicationModule(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4474

def process_registerApplicationModule(seqid, iprot, oprot)
  args = read_args(iprot, RegisterApplicationModule_args)
  result = RegisterApplicationModule_result.new()
  begin
    result.success = @handler.registerApplicationModule(args.authzToken, args.gatewayId, args.applicationModule)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'registerApplicationModule', seqid)
end

#process_registerComputeResource(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4882

def process_registerComputeResource(seqid, iprot, oprot)
  args = read_args(iprot, RegisterComputeResource_args)
  result = RegisterComputeResource_result.new()
  begin
    result.success = @handler.registerComputeResource(args.authzToken, args.computeResourceDescription)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'registerComputeResource', seqid)
end

#process_registerDataProduct(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6276

def process_registerDataProduct(seqid, iprot, oprot)
  args = read_args(iprot, RegisterDataProduct_args)
  result = RegisterDataProduct_result.new()
  begin
    result.success = @handler.registerDataProduct(args.authzToken, args.dataProductModel)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'registerDataProduct', seqid)
end

#process_registerGatewayResourceProfile(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5664

def process_registerGatewayResourceProfile(seqid, iprot, oprot)
  args = read_args(iprot, RegisterGatewayResourceProfile_args)
  result = RegisterGatewayResourceProfile_result.new()
  begin
    result.success = @handler.registerGatewayResourceProfile(args.authzToken, args.gatewayResourceProfile)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'registerGatewayResourceProfile', seqid)
end

#process_registerPwdCredential(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3889

def process_registerPwdCredential(seqid, iprot, oprot)
  args = read_args(iprot, RegisterPwdCredential_args)
  result = RegisterPwdCredential_result.new()
  begin
    result.success = @handler.registerPwdCredential(args.authzToken, args.loginUserName, args.password, args.description)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  end
  write_result(result, oprot, 'registerPwdCredential', seqid)
end

#process_registerReplicaLocation(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6310

def process_registerReplicaLocation(seqid, iprot, oprot)
  args = read_args(iprot, RegisterReplicaLocation_args)
  result = RegisterReplicaLocation_result.new()
  begin
    result.success = @handler.registerReplicaLocation(args.authzToken, args.replicaLocationModel)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'registerReplicaLocation', seqid)
end

#process_registerResourceJobManager(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5579

def process_registerResourceJobManager(seqid, iprot, oprot)
  args = read_args(iprot, RegisterResourceJobManager_args)
  result = RegisterResourceJobManager_result.new()
  begin
    result.success = @handler.registerResourceJobManager(args.authzToken, args.resourceJobManager)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'registerResourceJobManager', seqid)
end

#process_registerStorageResource(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4967

def process_registerStorageResource(seqid, iprot, oprot)
  args = read_args(iprot, RegisterStorageResource_args)
  result = RegisterStorageResource_result.new()
  begin
    result.success = @handler.registerStorageResource(args.authzToken, args.storageResourceDescription)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'registerStorageResource', seqid)
end

#process_registerUserResourceProfile(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5987

def process_registerUserResourceProfile(seqid, iprot, oprot)
  args = read_args(iprot, RegisterUserResourceProfile_args)
  result = RegisterUserResourceProfile_result.new()
  begin
    result.success = @handler.registerUserResourceProfile(args.authzToken, args.userResourceProfile)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'registerUserResourceProfile', seqid)
end

#process_removeGroupBatchQueueResourcePolicy(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6633

def process_removeGroupBatchQueueResourcePolicy(seqid, iprot, oprot)
  args = read_args(iprot, RemoveGroupBatchQueueResourcePolicy_args)
  result = RemoveGroupBatchQueueResourcePolicy_result.new()
  begin
    result.success = @handler.removeGroupBatchQueueResourcePolicy(args.authzToken, args.resourcePolicyId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'removeGroupBatchQueueResourcePolicy', seqid)
end

#process_removeGroupComputePrefs(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6599

def process_removeGroupComputePrefs(seqid, iprot, oprot)
  args = read_args(iprot, RemoveGroupComputePrefs_args)
  result = RemoveGroupComputePrefs_result.new()
  begin
    result.success = @handler.removeGroupComputePrefs(args.authzToken, args.computeResourceId, args.groupResourceProfileId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'removeGroupComputePrefs', seqid)
end

#process_removeGroupComputeResourcePolicy(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6616

def process_removeGroupComputeResourcePolicy(seqid, iprot, oprot)
  args = read_args(iprot, RemoveGroupComputeResourcePolicy_args)
  result = RemoveGroupComputeResourcePolicy_result.new()
  begin
    result.success = @handler.removeGroupComputeResourcePolicy(args.authzToken, args.resourcePolicyId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'removeGroupComputeResourcePolicy', seqid)
end

#process_removeGroupResourceProfile(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6565

def process_removeGroupResourceProfile(seqid, iprot, oprot)
  args = read_args(iprot, RemoveGroupResourceProfile_args)
  result = RemoveGroupResourceProfile_result.new()
  begin
    result.success = @handler.removeGroupResourceProfile(args.authzToken, args.groupResourceProfileId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'removeGroupResourceProfile', seqid)
end

#process_removeParser(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6820

def process_removeParser(seqid, iprot, oprot)
  args = read_args(iprot, RemoveParser_args)
  result = RemoveParser_result.new()
  begin
    result.success = @handler.removeParser(args.authzToken, args.parserId, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'removeParser', seqid)
end

#process_removeParsingTemplate(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6888

def process_removeParsingTemplate(seqid, iprot, oprot)
  args = read_args(iprot, RemoveParsingTemplate_args)
  result = RemoveParsingTemplate_result.new()
  begin
    result.success = @handler.removeParsingTemplate(args.authzToken, args.templateId, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'removeParsingTemplate', seqid)
end

#process_revokeSharingOfResourceFromGroups(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6412

def process_revokeSharingOfResourceFromGroups(seqid, iprot, oprot)
  args = read_args(iprot, RevokeSharingOfResourceFromGroups_args)
  result = RevokeSharingOfResourceFromGroups_result.new()
  begin
    result.success = @handler.revokeSharingOfResourceFromGroups(args.authzToken, args.resourceId, args.groupPermissionList)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'revokeSharingOfResourceFromGroups', seqid)
end

#process_revokeSharingOfResourceFromUsers(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6395

def process_revokeSharingOfResourceFromUsers(seqid, iprot, oprot)
  args = read_args(iprot, RevokeSharingOfResourceFromUsers_args)
  result = RevokeSharingOfResourceFromUsers_result.new()
  begin
    result.success = @handler.revokeSharingOfResourceFromUsers(args.authzToken, args.resourceId, args.userPermissionList)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'revokeSharingOfResourceFromUsers', seqid)
end

#process_saveParser(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6786

def process_saveParser(seqid, iprot, oprot)
  args = read_args(iprot, SaveParser_args)
  result = SaveParser_result.new()
  begin
    result.success = @handler.saveParser(args.authzToken, args.parser)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'saveParser', seqid)
end

#process_saveParsingTemplate(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6871

def process_saveParsingTemplate(seqid, iprot, oprot)
  args = read_args(iprot, SaveParsingTemplate_args)
  result = SaveParsingTemplate_result.new()
  begin
    result.success = @handler.saveParsingTemplate(args.authzToken, args.parsingTemplate)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'saveParsingTemplate', seqid)
end

#process_searchExperiments(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4078

def process_searchExperiments(seqid, iprot, oprot)
  args = read_args(iprot, SearchExperiments_args)
  result = SearchExperiments_result.new()
  begin
    result.success = @handler.searchExperiments(args.authzToken, args.gatewayId, args.userName, args.filters, args.limit, args.offset)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'searchExperiments', seqid)
end

#process_searchProjects(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4061

def process_searchProjects(seqid, iprot, oprot)
  args = read_args(iprot, SearchProjects_args)
  result = SearchProjects_result.new()
  begin
    result.success = @handler.searchProjects(args.authzToken, args.gatewayId, args.userName, args.filters, args.limit, args.offset)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'searchProjects', seqid)
end

#process_setupUserComputeResourcePreferencesForSSH(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5970

def process_setupUserComputeResourcePreferencesForSSH(seqid, iprot, oprot)
  args = read_args(iprot, SetupUserComputeResourcePreferencesForSSH_args)
  result = SetupUserComputeResourcePreferencesForSSH_result.new()
  begin
    result.success = @handler.setupUserComputeResourcePreferencesForSSH(args.authzToken, args.computeResourceId, args.userId, args.airavataCredStoreToken)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'setupUserComputeResourcePreferencesForSSH', seqid)
end

#process_shareResourceWithGroups(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6378

def process_shareResourceWithGroups(seqid, iprot, oprot)
  args = read_args(iprot, ShareResourceWithGroups_args)
  result = ShareResourceWithGroups_result.new()
  begin
    result.success = @handler.shareResourceWithGroups(args.authzToken, args.resourceId, args.groupPermissionList)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'shareResourceWithGroups', seqid)
end

#process_shareResourceWithUsers(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6361

def process_shareResourceWithUsers(seqid, iprot, oprot)
  args = read_args(iprot, ShareResourceWithUsers_args)
  result = ShareResourceWithUsers_result.new()
  begin
    result.success = @handler.shareResourceWithUsers(args.authzToken, args.resourceId, args.userPermissionList)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'shareResourceWithUsers', seqid)
end

#process_terminateExperiment(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4455

def process_terminateExperiment(seqid, iprot, oprot)
  args = read_args(iprot, TerminateExperiment_args)
  result = TerminateExperiment_result.new()
  begin
    @handler.terminateExperiment(args.authzToken, args.airavataExperimentId, args.gatewayId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::ExperimentNotFoundException => enf
    result.enf = enf
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'terminateExperiment', seqid)
end

#process_updateApplicationDeployment(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4610

def process_updateApplicationDeployment(seqid, iprot, oprot)
  args = read_args(iprot, UpdateApplicationDeployment_args)
  result = UpdateApplicationDeployment_result.new()
  begin
    result.success = @handler.updateApplicationDeployment(args.authzToken, args.appDeploymentId, args.applicationDeployment)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateApplicationDeployment', seqid)
end

#process_updateApplicationInterface(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4763

def process_updateApplicationInterface(seqid, iprot, oprot)
  args = read_args(iprot, UpdateApplicationInterface_args)
  result = UpdateApplicationInterface_result.new()
  begin
    result.success = @handler.updateApplicationInterface(args.authzToken, args.appInterfaceId, args.applicationInterface)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateApplicationInterface', seqid)
end

#process_updateApplicationModule(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4508

def process_updateApplicationModule(seqid, iprot, oprot)
  args = read_args(iprot, UpdateApplicationModule_args)
  result = UpdateApplicationModule_result.new()
  begin
    result.success = @handler.updateApplicationModule(args.authzToken, args.appModuleId, args.applicationModule)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateApplicationModule', seqid)
end

#process_updateCloudJobSubmissionDetails(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5239

def process_updateCloudJobSubmissionDetails(seqid, iprot, oprot)
  args = read_args(iprot, UpdateCloudJobSubmissionDetails_args)
  result = UpdateCloudJobSubmissionDetails_result.new()
  begin
    result.success = @handler.updateCloudJobSubmissionDetails(args.authzToken, args.jobSubmissionInterfaceId, args.sshJobSubmission)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateCloudJobSubmissionDetails', seqid)
end

#process_updateComputeResource(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4933

def process_updateComputeResource(seqid, iprot, oprot)
  args = read_args(iprot, UpdateComputeResource_args)
  result = UpdateComputeResource_result.new()
  begin
    result.success = @handler.updateComputeResource(args.authzToken, args.computeResourceId, args.computeResourceDescription)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateComputeResource', seqid)
end

#process_updateExperiment(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4239

def process_updateExperiment(seqid, iprot, oprot)
  args = read_args(iprot, UpdateExperiment_args)
  result = UpdateExperiment_result.new()
  begin
    @handler.updateExperiment(args.authzToken, args.airavataExperimentId, args.experiment)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::ExperimentNotFoundException => enf
    result.enf = enf
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateExperiment', seqid)
end

#process_updateExperimentConfiguration(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4258

def process_updateExperimentConfiguration(seqid, iprot, oprot)
  args = read_args(iprot, UpdateExperimentConfiguration_args)
  result = UpdateExperimentConfiguration_result.new()
  begin
    @handler.updateExperimentConfiguration(args.authzToken, args.airavataExperimentId, args.userConfiguration)
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateExperimentConfiguration', seqid)
end

#process_updateGateway(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3704

def process_updateGateway(seqid, iprot, oprot)
  args = read_args(iprot, UpdateGateway_args)
  result = UpdateGateway_result.new()
  begin
    result.success = @handler.updateGateway(args.authzToken, args.gatewayId, args.updatedGateway)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateGateway', seqid)
end

#process_updateGatewayComputeResourcePreference(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5851

def process_updateGatewayComputeResourcePreference(seqid, iprot, oprot)
  args = read_args(iprot, UpdateGatewayComputeResourcePreference_args)
  result = UpdateGatewayComputeResourcePreference_result.new()
  begin
    result.success = @handler.updateGatewayComputeResourcePreference(args.authzToken, args.gatewayID, args.computeResourceId, args.computeResourcePreference)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateGatewayComputeResourcePreference', seqid)
end

#process_updateGatewayResourceProfile(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5698

def process_updateGatewayResourceProfile(seqid, iprot, oprot)
  args = read_args(iprot, UpdateGatewayResourceProfile_args)
  result = UpdateGatewayResourceProfile_result.new()
  begin
    result.success = @handler.updateGatewayResourceProfile(args.authzToken, args.gatewayID, args.gatewayResourceProfile)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateGatewayResourceProfile', seqid)
end

#process_updateGatewayStoragePreference(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5868

def process_updateGatewayStoragePreference(seqid, iprot, oprot)
  args = read_args(iprot, UpdateGatewayStoragePreference_args)
  result = UpdateGatewayStoragePreference_result.new()
  begin
    result.success = @handler.updateGatewayStoragePreference(args.authzToken, args.gatewayID, args.storageId, args.storagePreference)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateGatewayStoragePreference', seqid)
end

#process_updateGridFTPDataMovementDetails(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5443

def process_updateGridFTPDataMovementDetails(seqid, iprot, oprot)
  args = read_args(iprot, UpdateGridFTPDataMovementDetails_args)
  result = UpdateGridFTPDataMovementDetails_result.new()
  begin
    result.success = @handler.updateGridFTPDataMovementDetails(args.authzToken, args.dataMovementInterfaceId, args.gridFTPDataMovement)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateGridFTPDataMovementDetails', seqid)
end

#process_updateGroupResourceProfile(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6531

def process_updateGroupResourceProfile(seqid, iprot, oprot)
  args = read_args(iprot, UpdateGroupResourceProfile_args)
  result = UpdateGroupResourceProfile_result.new()
  begin
    @handler.updateGroupResourceProfile(args.authzToken, args.groupResourceProfile)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateGroupResourceProfile', seqid)
end

#process_updateLocalDataMovementDetails(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5290

def process_updateLocalDataMovementDetails(seqid, iprot, oprot)
  args = read_args(iprot, UpdateLocalDataMovementDetails_args)
  result = UpdateLocalDataMovementDetails_result.new()
  begin
    result.success = @handler.updateLocalDataMovementDetails(args.authzToken, args.dataMovementInterfaceId, args.localDataMovement)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateLocalDataMovementDetails', seqid)
end

#process_updateLocalSubmissionDetails(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5069

def process_updateLocalSubmissionDetails(seqid, iprot, oprot)
  args = read_args(iprot, UpdateLocalSubmissionDetails_args)
  result = UpdateLocalSubmissionDetails_result.new()
  begin
    result.success = @handler.updateLocalSubmissionDetails(args.authzToken, args.jobSubmissionInterfaceId, args.localSubmission)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateLocalSubmissionDetails', seqid)
end

#process_updateNotification(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3806

def process_updateNotification(seqid, iprot, oprot)
  args = read_args(iprot, UpdateNotification_args)
  result = UpdateNotification_result.new()
  begin
    result.success = @handler.updateNotification(args.authzToken, args.notification)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateNotification', seqid)
end

#process_updateProject(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 3987

def process_updateProject(seqid, iprot, oprot)
  args = read_args(iprot, UpdateProject_args)
  result = UpdateProject_result.new()
  begin
    @handler.updateProject(args.authzToken, args.projectId, args.updatedProject)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::ProjectNotFoundException => pnfe
    result.pnfe = pnfe
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateProject', seqid)
end

#process_updateResourceJobManager(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5596

def process_updateResourceJobManager(seqid, iprot, oprot)
  args = read_args(iprot, UpdateResourceJobManager_args)
  result = UpdateResourceJobManager_result.new()
  begin
    result.success = @handler.updateResourceJobManager(args.authzToken, args.resourceJobManagerId, args.updatedResourceJobManager)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateResourceJobManager', seqid)
end

#process_updateResourceScheduleing(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4269

def process_updateResourceScheduleing(seqid, iprot, oprot)
  args = read_args(iprot, UpdateResourceScheduleing_args)
  result = UpdateResourceScheduleing_result.new()
  begin
    @handler.updateResourceScheduleing(args.authzToken, args.airavataExperimentId, args.resourceScheduling)
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateResourceScheduleing', seqid)
end

#process_updateSCPDataMovementDetails(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5341

def process_updateSCPDataMovementDetails(seqid, iprot, oprot)
  args = read_args(iprot, UpdateSCPDataMovementDetails_args)
  result = UpdateSCPDataMovementDetails_result.new()
  begin
    result.success = @handler.updateSCPDataMovementDetails(args.authzToken, args.dataMovementInterfaceId, args.scpDataMovement)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateSCPDataMovementDetails', seqid)
end

#process_updateSSHJobSubmissionDetails(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5222

def process_updateSSHJobSubmissionDetails(seqid, iprot, oprot)
  args = read_args(iprot, UpdateSSHJobSubmissionDetails_args)
  result = UpdateSSHJobSubmissionDetails_result.new()
  begin
    result.success = @handler.updateSSHJobSubmissionDetails(args.authzToken, args.jobSubmissionInterfaceId, args.sshJobSubmission)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateSSHJobSubmissionDetails', seqid)
end

#process_updateStorageResource(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5018

def process_updateStorageResource(seqid, iprot, oprot)
  args = read_args(iprot, UpdateStorageResource_args)
  result = UpdateStorageResource_result.new()
  begin
    result.success = @handler.updateStorageResource(args.authzToken, args.storageResourceId, args.storageResourceDescription)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateStorageResource', seqid)
end

#process_updateUnicoreDataMovementDetails(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5392

def process_updateUnicoreDataMovementDetails(seqid, iprot, oprot)
  args = read_args(iprot, UpdateUnicoreDataMovementDetails_args)
  result = UpdateUnicoreDataMovementDetails_result.new()
  begin
    result.success = @handler.updateUnicoreDataMovementDetails(args.authzToken, args.dataMovementInterfaceId, args.unicoreDataMovement)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateUnicoreDataMovementDetails', seqid)
end

#process_updateUnicoreJobSubmissionDetails(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 5256

def process_updateUnicoreJobSubmissionDetails(seqid, iprot, oprot)
  args = read_args(iprot, UpdateUnicoreJobSubmissionDetails_args)
  result = UpdateUnicoreJobSubmissionDetails_result.new()
  begin
    result.success = @handler.updateUnicoreJobSubmissionDetails(args.authzToken, args.jobSubmissionInterfaceId, args.unicoreJobSubmission)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateUnicoreJobSubmissionDetails', seqid)
end

#process_updateUserComputeResourcePreference(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6191

def process_updateUserComputeResourcePreference(seqid, iprot, oprot)
  args = read_args(iprot, UpdateUserComputeResourcePreference_args)
  result = UpdateUserComputeResourcePreference_result.new()
  begin
    result.success = @handler.updateUserComputeResourcePreference(args.authzToken, args.userId, args.gatewayID, args.userComputeResourceId, args.userComputeResourcePreference)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateUserComputeResourcePreference', seqid)
end

#process_updateUserResourceProfile(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6038

def process_updateUserResourceProfile(seqid, iprot, oprot)
  args = read_args(iprot, UpdateUserResourceProfile_args)
  result = UpdateUserResourceProfile_result.new()
  begin
    result.success = @handler.updateUserResourceProfile(args.authzToken, args.userId, args.gatewayID, args.userResourceProfile)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateUserResourceProfile', seqid)
end

#process_updateUserStoragePreference(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6208

def process_updateUserStoragePreference(seqid, iprot, oprot)
  args = read_args(iprot, UpdateUserStoragePreference_args)
  result = UpdateUserStoragePreference_result.new()
  begin
    result.success = @handler.updateUserStoragePreference(args.authzToken, args.userId, args.gatewayID, args.userStorageId, args.userStoragePreference)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'updateUserStoragePreference', seqid)
end

#process_userHasAccess(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 6497

def process_userHasAccess(seqid, iprot, oprot)
  args = read_args(iprot, UserHasAccess_args)
  result = UserHasAccess_result.new()
  begin
    result.success = @handler.userHasAccess(args.authzToken, args.resourceId, args.permissionType)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'userHasAccess', seqid)
end

#process_validateExperiment(seqid, iprot, oprot) ⇒ `Object`

# File 'lib/airavata.rb', line 4280

def process_validateExperiment(seqid, iprot, oprot)
  args = read_args(iprot, ValidateExperiment_args)
  result = ValidateExperiment_result.new()
  begin
    result.success = @handler.validateExperiment(args.authzToken, args.airavataExperimentId)
  rescue ::InvalidRequestException => ire
    result.ire = ire
  rescue ::ExperimentNotFoundException => enf
    result.enf = enf
  rescue ::AiravataClientException => ace
    result.ace = ace
  rescue ::AiravataSystemException => ase
    result.ase = ase
  rescue ::AuthorizationException => ae
    result.ae = ae
  end
  write_result(result, oprot, 'validateExperiment', seqid)
end

Class: Airavata::Processor

Instance Method Summary collapse

Methods inherited from BaseAPI::Processor

Instance Method Details

#process_addCloudJobSubmissionDetails(seqid, iprot, oprot) ⇒ Object

#process_addGateway(seqid, iprot, oprot) ⇒ Object

#process_addGatewayComputeResourcePreference(seqid, iprot, oprot) ⇒ Object

#process_addGatewayStoragePreference(seqid, iprot, oprot) ⇒ Object

#process_addGridFTPDataMovementDetails(seqid, iprot, oprot) ⇒ Object

#process_addLocalDataMovementDetails(seqid, iprot, oprot) ⇒ Object

#process_addLocalSubmissionDetails(seqid, iprot, oprot) ⇒ Object

#process_addSCPDataMovementDetails(seqid, iprot, oprot) ⇒ Object

#process_addSSHForkJobSubmissionDetails(seqid, iprot, oprot) ⇒ Object

#process_addSSHJobSubmissionDetails(seqid, iprot, oprot) ⇒ Object

#process_addUnicoreDataMovementDetails(seqid, iprot, oprot) ⇒ Object

#process_addUNICOREJobSubmissionDetails(seqid, iprot, oprot) ⇒ Object

#process_addUserComputeResourcePreference(seqid, iprot, oprot) ⇒ Object

#process_addUserStoragePreference(seqid, iprot, oprot) ⇒ Object

#process_changeDataMovementPriorities(seqid, iprot, oprot) ⇒ Object

#process_changeDataMovementPriority(seqid, iprot, oprot) ⇒ Object

#process_changeJobSubmissionPriorities(seqid, iprot, oprot) ⇒ Object

#process_changeJobSubmissionPriority(seqid, iprot, oprot) ⇒ Object

#process_cloneApplicationInterface(seqid, iprot, oprot) ⇒ Object

#process_cloneExperiment(seqid, iprot, oprot) ⇒ Object

#process_cloneExperimentByAdmin(seqid, iprot, oprot) ⇒ Object

#process_createExperiment(seqid, iprot, oprot) ⇒ Object

#process_createGroupResourceProfile(seqid, iprot, oprot) ⇒ Object

#process_createNotification(seqid, iprot, oprot) ⇒ Object

#process_createProject(seqid, iprot, oprot) ⇒ Object

#process_deleteApplicationDeployment(seqid, iprot, oprot) ⇒ Object

#process_deleteApplicationInterface(seqid, iprot, oprot) ⇒ Object

#process_deleteApplicationModule(seqid, iprot, oprot) ⇒ Object

#process_deleteBatchQueue(seqid, iprot, oprot) ⇒ Object

#process_deleteComputeResource(seqid, iprot, oprot) ⇒ Object

#process_deleteDataMovementInterface(seqid, iprot, oprot) ⇒ Object

#process_deleteExperiment(seqid, iprot, oprot) ⇒ Object

#process_deleteGateway(seqid, iprot, oprot) ⇒ Object

#process_deleteGatewayComputeResourcePreference(seqid, iprot, oprot) ⇒ Object

#process_deleteGatewayResourceProfile(seqid, iprot, oprot) ⇒ Object

#process_deleteGatewayStoragePreference(seqid, iprot, oprot) ⇒ Object

#process_deleteJobSubmissionInterface(seqid, iprot, oprot) ⇒ Object

#process_deleteNotification(seqid, iprot, oprot) ⇒ Object

#process_deleteProject(seqid, iprot, oprot) ⇒ Object

#process_deletePWDCredential(seqid, iprot, oprot) ⇒ Object

#process_deleteResourceJobManager(seqid, iprot, oprot) ⇒ Object

#process_deleteSSHPubKey(seqid, iprot, oprot) ⇒ Object

#process_deleteStorageResource(seqid, iprot, oprot) ⇒ Object

#process_deleteUserComputeResourcePreference(seqid, iprot, oprot) ⇒ Object

#process_deleteUserResourceProfile(seqid, iprot, oprot) ⇒ Object

#process_deleteUserStoragePreference(seqid, iprot, oprot) ⇒ Object

#process_doesUserHaveSSHAccount(seqid, iprot, oprot) ⇒ Object

#process_generateAndRegisterSSHKeys(seqid, iprot, oprot) ⇒ Object

#process_getAccessibleApplicationDeployments(seqid, iprot, oprot) ⇒ Object

#process_getAccessibleAppModules(seqid, iprot, oprot) ⇒ Object

#process_getAllAccessibleGroups(seqid, iprot, oprot) ⇒ Object

#process_getAllAccessibleUsers(seqid, iprot, oprot) ⇒ Object

#process_getAllApplicationDeployments(seqid, iprot, oprot) ⇒ Object

#process_getAllApplicationInterfaceNames(seqid, iprot, oprot) ⇒ Object

#process_getAllApplicationInterfaces(seqid, iprot, oprot) ⇒ Object

#process_getAllAppModules(seqid, iprot, oprot) ⇒ Object

#process_getAllComputeResourceNames(seqid, iprot, oprot) ⇒ Object

#process_getAllCredentialSummaries(seqid, iprot, oprot) ⇒ Object

#process_getAllDirectlyAccessibleGroups(seqid, iprot, oprot) ⇒ Object

#process_getAllDirectlyAccessibleUsers(seqid, iprot, oprot) ⇒ Object

#process_getAllGatewayComputeResourcePreferences(seqid, iprot, oprot) ⇒ Object

#process_getAllGatewayResourceProfiles(seqid, iprot, oprot) ⇒ Object

#process_getAllGateways(seqid, iprot, oprot) ⇒ Object

#process_getAllGatewayStoragePreferences(seqid, iprot, oprot) ⇒ Object

#process_getAllNotifications(seqid, iprot, oprot) ⇒ Object

#process_getAllStorageResourceNames(seqid, iprot, oprot) ⇒ Object

#process_getAllUserComputeResourcePreferences(seqid, iprot, oprot) ⇒ Object

#process_getAllUserResourceProfiles(seqid, iprot, oprot) ⇒ Object

#process_getAllUsersInGateway(seqid, iprot, oprot) ⇒ Object

#process_getAllUserStoragePreferences(seqid, iprot, oprot) ⇒ Object

#process_getApplicationDeployment(seqid, iprot, oprot) ⇒ Object

#process_getApplicationDeploymentsForAppModuleAndGroupResourceProfile(seqid, iprot, oprot) ⇒ Object

#process_getApplicationInputs(seqid, iprot, oprot) ⇒ Object

#process_getApplicationInterface(seqid, iprot, oprot) ⇒ Object

#process_getApplicationModule(seqid, iprot, oprot) ⇒ Object

#process_getApplicationOutputs(seqid, iprot, oprot) ⇒ Object

#process_addCloudJobSubmissionDetails(seqid, iprot, oprot) ⇒ `Object`

#process_addGateway(seqid, iprot, oprot) ⇒ `Object`

#process_addGatewayComputeResourcePreference(seqid, iprot, oprot) ⇒ `Object`

#process_addGatewayStoragePreference(seqid, iprot, oprot) ⇒ `Object`

#process_addGridFTPDataMovementDetails(seqid, iprot, oprot) ⇒ `Object`

#process_addLocalDataMovementDetails(seqid, iprot, oprot) ⇒ `Object`

#process_addLocalSubmissionDetails(seqid, iprot, oprot) ⇒ `Object`

#process_addSCPDataMovementDetails(seqid, iprot, oprot) ⇒ `Object`

#process_addSSHForkJobSubmissionDetails(seqid, iprot, oprot) ⇒ `Object`

#process_addSSHJobSubmissionDetails(seqid, iprot, oprot) ⇒ `Object`

#process_addUnicoreDataMovementDetails(seqid, iprot, oprot) ⇒ `Object`

#process_addUNICOREJobSubmissionDetails(seqid, iprot, oprot) ⇒ `Object`

#process_addUserComputeResourcePreference(seqid, iprot, oprot) ⇒ `Object`

#process_addUserStoragePreference(seqid, iprot, oprot) ⇒ `Object`

#process_changeDataMovementPriorities(seqid, iprot, oprot) ⇒ `Object`

#process_changeDataMovementPriority(seqid, iprot, oprot) ⇒ `Object`

#process_changeJobSubmissionPriorities(seqid, iprot, oprot) ⇒ `Object`

#process_changeJobSubmissionPriority(seqid, iprot, oprot) ⇒ `Object`

#process_cloneApplicationInterface(seqid, iprot, oprot) ⇒ `Object`

#process_cloneExperiment(seqid, iprot, oprot) ⇒ `Object`

#process_cloneExperimentByAdmin(seqid, iprot, oprot) ⇒ `Object`

#process_createExperiment(seqid, iprot, oprot) ⇒ `Object`

#process_createGroupResourceProfile(seqid, iprot, oprot) ⇒ `Object`

#process_createNotification(seqid, iprot, oprot) ⇒ `Object`

#process_createProject(seqid, iprot, oprot) ⇒ `Object`

#process_deleteApplicationDeployment(seqid, iprot, oprot) ⇒ `Object`

#process_deleteApplicationInterface(seqid, iprot, oprot) ⇒ `Object`

#process_deleteApplicationModule(seqid, iprot, oprot) ⇒ `Object`

#process_deleteBatchQueue(seqid, iprot, oprot) ⇒ `Object`

#process_deleteComputeResource(seqid, iprot, oprot) ⇒ `Object`

#process_deleteDataMovementInterface(seqid, iprot, oprot) ⇒ `Object`

#process_deleteExperiment(seqid, iprot, oprot) ⇒ `Object`

#process_deleteGateway(seqid, iprot, oprot) ⇒ `Object`

#process_deleteGatewayComputeResourcePreference(seqid, iprot, oprot) ⇒ `Object`

#process_deleteGatewayResourceProfile(seqid, iprot, oprot) ⇒ `Object`

#process_deleteGatewayStoragePreference(seqid, iprot, oprot) ⇒ `Object`

#process_deleteJobSubmissionInterface(seqid, iprot, oprot) ⇒ `Object`

#process_deleteNotification(seqid, iprot, oprot) ⇒ `Object`

#process_deleteProject(seqid, iprot, oprot) ⇒ `Object`

#process_deletePWDCredential(seqid, iprot, oprot) ⇒ `Object`

#process_deleteResourceJobManager(seqid, iprot, oprot) ⇒ `Object`

#process_deleteSSHPubKey(seqid, iprot, oprot) ⇒ `Object`

#process_deleteStorageResource(seqid, iprot, oprot) ⇒ `Object`

#process_deleteUserComputeResourcePreference(seqid, iprot, oprot) ⇒ `Object`

#process_deleteUserResourceProfile(seqid, iprot, oprot) ⇒ `Object`

#process_deleteUserStoragePreference(seqid, iprot, oprot) ⇒ `Object`

#process_doesUserHaveSSHAccount(seqid, iprot, oprot) ⇒ `Object`

#process_generateAndRegisterSSHKeys(seqid, iprot, oprot) ⇒ `Object`

#process_getAccessibleApplicationDeployments(seqid, iprot, oprot) ⇒ `Object`

#process_getAccessibleAppModules(seqid, iprot, oprot) ⇒ `Object`

#process_getAllAccessibleGroups(seqid, iprot, oprot) ⇒ `Object`

#process_getAllAccessibleUsers(seqid, iprot, oprot) ⇒ `Object`

#process_getAllApplicationDeployments(seqid, iprot, oprot) ⇒ `Object`

#process_getAllApplicationInterfaceNames(seqid, iprot, oprot) ⇒ `Object`

#process_getAllApplicationInterfaces(seqid, iprot, oprot) ⇒ `Object`

#process_getAllAppModules(seqid, iprot, oprot) ⇒ `Object`

#process_getAllComputeResourceNames(seqid, iprot, oprot) ⇒ `Object`

#process_getAllCredentialSummaries(seqid, iprot, oprot) ⇒ `Object`

#process_getAllDirectlyAccessibleGroups(seqid, iprot, oprot) ⇒ `Object`

#process_getAllDirectlyAccessibleUsers(seqid, iprot, oprot) ⇒ `Object`

#process_getAllGatewayComputeResourcePreferences(seqid, iprot, oprot) ⇒ `Object`

#process_getAllGatewayResourceProfiles(seqid, iprot, oprot) ⇒ `Object`

#process_getAllGateways(seqid, iprot, oprot) ⇒ `Object`

#process_getAllGatewayStoragePreferences(seqid, iprot, oprot) ⇒ `Object`

#process_getAllNotifications(seqid, iprot, oprot) ⇒ `Object`

#process_getAllStorageResourceNames(seqid, iprot, oprot) ⇒ `Object`

#process_getAllUserComputeResourcePreferences(seqid, iprot, oprot) ⇒ `Object`

#process_getAllUserResourceProfiles(seqid, iprot, oprot) ⇒ `Object`

#process_getAllUsersInGateway(seqid, iprot, oprot) ⇒ `Object`

#process_getAllUserStoragePreferences(seqid, iprot, oprot) ⇒ `Object`

#process_getApplicationDeployment(seqid, iprot, oprot) ⇒ `Object`

#process_getApplicationDeploymentsForAppModuleAndGroupResourceProfile(seqid, iprot, oprot) ⇒ `Object`

#process_getApplicationInputs(seqid, iprot, oprot) ⇒ `Object`

#process_getApplicationInterface(seqid, iprot, oprot) ⇒ `Object`

#process_getApplicationModule(seqid, iprot, oprot) ⇒ `Object`

#process_getApplicationOutputs(seqid, iprot, oprot) ⇒ `Object`

#process_getAppModuleDeployedResources(seqid, iprot, oprot) ⇒ `Object`

#process_getAvailableAppInterfaceComputeResources(seqid, iprot, oprot) ⇒ `Object`

#process_getBatchQueueResourcePolicy(seqid, iprot, oprot) ⇒ `Object`

#process_getChildDataProducts(seqid, iprot, oprot) ⇒ `Object`