WRENCH REST API

WRENCH

addBareMetalComputeService

Create and start a bare-metal compute service.


/simulation/{simid}/addBareMetalComputeService

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/addBareMetalComputeService"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addBareMetalComputeService_body body = ; // Simid_addBareMetalComputeService_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.addBareMetalComputeService(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addBareMetalComputeService");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addBareMetalComputeService_body body = ; // Simid_addBareMetalComputeService_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.addBareMetalComputeService(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addBareMetalComputeService");
            e.printStackTrace();
        }
    }
}
Simid_addBareMetalComputeService_body *body = ; // Input to start a new service.
String *simid = simid_example; // ID of the simulation

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Create and start a bare-metal compute service.
[apiInstance addBareMetalComputeServiceWith:body
    simid:simid
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_addBareMetalComputeService_body}} Input to start a new service.
var simid = simid_example; // {{String}} ID of the simulation

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addBareMetalComputeService(bodysimid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addBareMetalComputeServiceExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Simid_addBareMetalComputeService_body(); // Simid_addBareMetalComputeService_body | Input to start a new service.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Create and start a bare-metal compute service.
                ServiceResponse result = apiInstance.addBareMetalComputeService(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addBareMetalComputeService: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_addBareMetalComputeService_body | Input to start a new service.
$simid = simid_example; // String | ID of the simulation

try {
    $result = $api_instance->addBareMetalComputeService($body, $simid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->addBareMetalComputeService: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_addBareMetalComputeService_body->new(); # Simid_addBareMetalComputeService_body | Input to start a new service.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->addBareMetalComputeService(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addBareMetalComputeService: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Simid_addBareMetalComputeService_body | Input to start a new service.
simid = simid_example # String | ID of the simulation

try: 
    # Create and start a bare-metal compute service.
    api_response = api_instance.add_bare_metal_compute_service(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addBareMetalComputeService: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 405 - Invalid input


addBatchComputeService

Create and start a batch compute service.


/simulation/{simid}/addBatchComputeService

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/addBatchComputeService"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addBatchComputeService_body body = ; // Simid_addBatchComputeService_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.addBatchComputeService(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addBatchComputeService");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addBatchComputeService_body body = ; // Simid_addBatchComputeService_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.addBatchComputeService(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addBatchComputeService");
            e.printStackTrace();
        }
    }
}
Simid_addBatchComputeService_body *body = ; // Input to start a new service.
String *simid = simid_example; // ID of the simulation

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Create and start a batch compute service.
[apiInstance addBatchComputeServiceWith:body
    simid:simid
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_addBatchComputeService_body}} Input to start a new service.
var simid = simid_example; // {{String}} ID of the simulation

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addBatchComputeService(bodysimid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addBatchComputeServiceExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Simid_addBatchComputeService_body(); // Simid_addBatchComputeService_body | Input to start a new service.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Create and start a batch compute service.
                ServiceResponse result = apiInstance.addBatchComputeService(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addBatchComputeService: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_addBatchComputeService_body | Input to start a new service.
$simid = simid_example; // String | ID of the simulation

try {
    $result = $api_instance->addBatchComputeService($body, $simid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->addBatchComputeService: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_addBatchComputeService_body->new(); # Simid_addBatchComputeService_body | Input to start a new service.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->addBatchComputeService(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addBatchComputeService: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Simid_addBatchComputeService_body | Input to start a new service.
simid = simid_example # String | ID of the simulation

try: 
    # Create and start a batch compute service.
    api_response = api_instance.add_batch_compute_service(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addBatchComputeService: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 405 - Invalid input


addCloudComputeService

Create and start a cloud compute service.


/simulation/{simid}/addCloudComputeService

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/addCloudComputeService"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addCloudComputeService_body body = ; // Simid_addCloudComputeService_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.addCloudComputeService(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addCloudComputeService");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addCloudComputeService_body body = ; // Simid_addCloudComputeService_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.addCloudComputeService(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addCloudComputeService");
            e.printStackTrace();
        }
    }
}
Simid_addCloudComputeService_body *body = ; // Input to start a new service.
String *simid = simid_example; // ID of the simulation

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Create and start a cloud compute service.
[apiInstance addCloudComputeServiceWith:body
    simid:simid
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_addCloudComputeService_body}} Input to start a new service.
var simid = simid_example; // {{String}} ID of the simulation

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addCloudComputeService(bodysimid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addCloudComputeServiceExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Simid_addCloudComputeService_body(); // Simid_addCloudComputeService_body | Input to start a new service.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Create and start a cloud compute service.
                ServiceResponse result = apiInstance.addCloudComputeService(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addCloudComputeService: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_addCloudComputeService_body | Input to start a new service.
$simid = simid_example; // String | ID of the simulation

try {
    $result = $api_instance->addCloudComputeService($body, $simid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->addCloudComputeService: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_addCloudComputeService_body->new(); # Simid_addCloudComputeService_body | Input to start a new service.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->addCloudComputeService(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addCloudComputeService: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Simid_addCloudComputeService_body | Input to start a new service.
simid = simid_example # String | ID of the simulation

try: 
    # Create and start a cloud compute service.
    api_response = api_instance.add_cloud_compute_service(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addCloudComputeService: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 405 - Invalid input


addComputeAction

Add a compute action to compound job


/simulation/{simid}/compoundJobs/{compound_job_name}/addComputeAction

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/addComputeAction"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Compound_job_name_addComputeAction_body body = ; // Compound_job_name_addComputeAction_body | Input to add a compute action.
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            GenericRespone result = apiInstance.addComputeAction(body, simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addComputeAction");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Compound_job_name_addComputeAction_body body = ; // Compound_job_name_addComputeAction_body | Input to add a compute action.
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            GenericRespone result = apiInstance.addComputeAction(body, simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addComputeAction");
            e.printStackTrace();
        }
    }
}
Compound_job_name_addComputeAction_body *body = ; // Input to add a compute action.
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Add a compute action to compound job
[apiInstance addComputeActionWith:body
    simid:simid
    compoundJobName:compoundJobName
              completionHandler: ^(GenericRespone output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Compound_job_name_addComputeAction_body}} Input to add a compute action.
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addComputeAction(bodysimidcompoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addComputeActionExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Compound_job_name_addComputeAction_body(); // Compound_job_name_addComputeAction_body | Input to add a compute action.
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Add a compute action to compound job
                GenericRespone result = apiInstance.addComputeAction(body, simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addComputeAction: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Compound_job_name_addComputeAction_body | Input to add a compute action.
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->addComputeAction($body, $simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->addComputeAction: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Compound_job_name_addComputeAction_body->new(); # Compound_job_name_addComputeAction_body | Input to add a compute action.
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->addComputeAction(body => $body, simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addComputeAction: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Compound_job_name_addComputeAction_body | Input to add a compute action.
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Add a compute action to compound job
    api_response = api_instance.add_compute_action(body, simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addComputeAction: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


addFile

Add a file to the simulation.


/simulation/{simid}/addFile

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/addFile"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addFile_body body = ; // Simid_addFile_body | Input to add a new file.
        String simid = simid_example; // String | ID of the simulation
        try {
            GenericResponse result = apiInstance.addFile(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addFile");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addFile_body body = ; // Simid_addFile_body | Input to add a new file.
        String simid = simid_example; // String | ID of the simulation
        try {
            GenericResponse result = apiInstance.addFile(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addFile");
            e.printStackTrace();
        }
    }
}
Simid_addFile_body *body = ; // Input to add a new file.
String *simid = simid_example; // ID of the simulation

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Add a file to the simulation.
[apiInstance addFileWith:body
    simid:simid
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_addFile_body}} Input to add a new file.
var simid = simid_example; // {{String}} ID of the simulation

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addFile(bodysimid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addFileExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Simid_addFile_body(); // Simid_addFile_body | Input to add a new file.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Add a file to the simulation.
                GenericResponse result = apiInstance.addFile(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addFile: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_addFile_body | Input to add a new file.
$simid = simid_example; // String | ID of the simulation

try {
    $result = $api_instance->addFile($body, $simid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->addFile: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_addFile_body->new(); # Simid_addFile_body | Input to add a new file.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->addFile(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addFile: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Simid_addFile_body | Input to add a new file.
simid = simid_example # String | ID of the simulation

try: 
    # Add a file to the simulation.
    api_response = api_instance.add_file(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addFile: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 404 - Task not found

Status: 405 - Invalid input


addFileCopyAction

Add a file copy action to compound job


/simulation/{simid}/compoundJobs/{compound_job_name}/addFileCopyAction

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/addFileCopyAction"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Compound_job_name_addFileCopyAction_body body = ; // Compound_job_name_addFileCopyAction_body | Input to add a file copy action.
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            GenericResponse result = apiInstance.addFileCopyAction(body, simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addFileCopyAction");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Compound_job_name_addFileCopyAction_body body = ; // Compound_job_name_addFileCopyAction_body | Input to add a file copy action.
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            GenericResponse result = apiInstance.addFileCopyAction(body, simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addFileCopyAction");
            e.printStackTrace();
        }
    }
}
Compound_job_name_addFileCopyAction_body *body = ; // Input to add a file copy action.
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Add a file copy action to compound job
[apiInstance addFileCopyActionWith:body
    simid:simid
    compoundJobName:compoundJobName
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Compound_job_name_addFileCopyAction_body}} Input to add a file copy action.
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addFileCopyAction(bodysimidcompoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addFileCopyActionExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Compound_job_name_addFileCopyAction_body(); // Compound_job_name_addFileCopyAction_body | Input to add a file copy action.
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Add a file copy action to compound job
                GenericResponse result = apiInstance.addFileCopyAction(body, simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addFileCopyAction: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Compound_job_name_addFileCopyAction_body | Input to add a file copy action.
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->addFileCopyAction($body, $simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->addFileCopyAction: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Compound_job_name_addFileCopyAction_body->new(); # Compound_job_name_addFileCopyAction_body | Input to add a file copy action.
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->addFileCopyAction(body => $body, simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addFileCopyAction: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Compound_job_name_addFileCopyAction_body | Input to add a file copy action.
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Add a file copy action to compound job
    api_response = api_instance.add_file_copy_action(body, simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addFileCopyAction: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


addFileDeleteAction

Add a file delete action to compound job


/simulation/{simid}/compoundJobs/{compound_job_name}/addFileDeleteAction

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/addFileDeleteAction"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Compound_job_name_addFileDeleteAction_body body = ; // Compound_job_name_addFileDeleteAction_body | Input to add a file delete action.
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            GenericResponse result = apiInstance.addFileDeleteAction(body, simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addFileDeleteAction");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Compound_job_name_addFileDeleteAction_body body = ; // Compound_job_name_addFileDeleteAction_body | Input to add a file delete action.
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            GenericResponse result = apiInstance.addFileDeleteAction(body, simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addFileDeleteAction");
            e.printStackTrace();
        }
    }
}
Compound_job_name_addFileDeleteAction_body *body = ; // Input to add a file delete action.
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Add a file delete action to compound job
[apiInstance addFileDeleteActionWith:body
    simid:simid
    compoundJobName:compoundJobName
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Compound_job_name_addFileDeleteAction_body}} Input to add a file delete action.
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addFileDeleteAction(bodysimidcompoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addFileDeleteActionExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Compound_job_name_addFileDeleteAction_body(); // Compound_job_name_addFileDeleteAction_body | Input to add a file delete action.
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Add a file delete action to compound job
                GenericResponse result = apiInstance.addFileDeleteAction(body, simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addFileDeleteAction: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Compound_job_name_addFileDeleteAction_body | Input to add a file delete action.
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->addFileDeleteAction($body, $simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->addFileDeleteAction: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Compound_job_name_addFileDeleteAction_body->new(); # Compound_job_name_addFileDeleteAction_body | Input to add a file delete action.
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->addFileDeleteAction(body => $body, simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addFileDeleteAction: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Compound_job_name_addFileDeleteAction_body | Input to add a file delete action.
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Add a file delete action to compound job
    api_response = api_instance.add_file_delete_action(body, simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addFileDeleteAction: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


addFileReadAction

Add a file read action to compound job


/simulation/{simid}/compoundJobs/{compound_job_name}/addFileReadAction

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/addFileReadAction"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        FileReadAction body = ; // FileReadAction | Input to add a file read action.
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            AddActionResponse result = apiInstance.addFileReadAction(body, simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addFileReadAction");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        FileReadAction body = ; // FileReadAction | Input to add a file read action.
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            AddActionResponse result = apiInstance.addFileReadAction(body, simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addFileReadAction");
            e.printStackTrace();
        }
    }
}
FileReadAction *body = ; // Input to add a file read action.
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Add a file read action to compound job
[apiInstance addFileReadActionWith:body
    simid:simid
    compoundJobName:compoundJobName
              completionHandler: ^(AddActionResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{FileReadAction}} Input to add a file read action.
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addFileReadAction(bodysimidcompoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addFileReadActionExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new FileReadAction(); // FileReadAction | Input to add a file read action.
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Add a file read action to compound job
                AddActionResponse result = apiInstance.addFileReadAction(body, simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addFileReadAction: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // FileReadAction | Input to add a file read action.
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->addFileReadAction($body, $simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->addFileReadAction: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::FileReadAction->new(); # FileReadAction | Input to add a file read action.
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->addFileReadAction(body => $body, simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addFileReadAction: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # FileReadAction | Input to add a file read action.
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Add a file read action to compound job
    api_response = api_instance.add_file_read_action(body, simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addFileReadAction: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 404 - Compound job not found

Status: 405 - Invalid input


addFileRegistryService

Create and start a file registry service.


/simulation/{simid}/addFileRegistryService

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/addFileRegistryService"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addFileRegistryService_body body = ; // Simid_addFileRegistryService_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.addFileRegistryService(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addFileRegistryService");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addFileRegistryService_body body = ; // Simid_addFileRegistryService_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.addFileRegistryService(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addFileRegistryService");
            e.printStackTrace();
        }
    }
}
Simid_addFileRegistryService_body *body = ; // Input to start a new service.
String *simid = simid_example; // ID of the simulation

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Create and start a file registry service.
[apiInstance addFileRegistryServiceWith:body
    simid:simid
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_addFileRegistryService_body}} Input to start a new service.
var simid = simid_example; // {{String}} ID of the simulation

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addFileRegistryService(bodysimid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addFileRegistryServiceExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Simid_addFileRegistryService_body(); // Simid_addFileRegistryService_body | Input to start a new service.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Create and start a file registry service.
                ServiceResponse result = apiInstance.addFileRegistryService(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addFileRegistryService: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_addFileRegistryService_body | Input to start a new service.
$simid = simid_example; // String | ID of the simulation

try {
    $result = $api_instance->addFileRegistryService($body, $simid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->addFileRegistryService: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_addFileRegistryService_body->new(); # Simid_addFileRegistryService_body | Input to start a new service.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->addFileRegistryService(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addFileRegistryService: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Simid_addFileRegistryService_body | Input to start a new service.
simid = simid_example # String | ID of the simulation

try: 
    # Create and start a file registry service.
    api_response = api_instance.add_file_registry_service(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addFileRegistryService: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 405 - Invalid input


addFileWriteAction

Add a file write action to compound job.


/simulation/{simid}/compoundJobs/{compound_job_name}/addFileWriteAction

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/addFileWriteAction"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Compound_job_name_addFileWriteAction_body body = ; // Compound_job_name_addFileWriteAction_body | Input to add a file write action.
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            GenericResponse result = apiInstance.addFileWriteAction(body, simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addFileWriteAction");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Compound_job_name_addFileWriteAction_body body = ; // Compound_job_name_addFileWriteAction_body | Input to add a file write action.
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            GenericResponse result = apiInstance.addFileWriteAction(body, simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addFileWriteAction");
            e.printStackTrace();
        }
    }
}
Compound_job_name_addFileWriteAction_body *body = ; // Input to add a file write action.
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Add a file write action to compound job.
[apiInstance addFileWriteActionWith:body
    simid:simid
    compoundJobName:compoundJobName
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Compound_job_name_addFileWriteAction_body}} Input to add a file write action.
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addFileWriteAction(bodysimidcompoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addFileWriteActionExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Compound_job_name_addFileWriteAction_body(); // Compound_job_name_addFileWriteAction_body | Input to add a file write action.
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Add a file write action to compound job.
                GenericResponse result = apiInstance.addFileWriteAction(body, simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addFileWriteAction: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Compound_job_name_addFileWriteAction_body | Input to add a file write action.
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->addFileWriteAction($body, $simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->addFileWriteAction: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Compound_job_name_addFileWriteAction_body->new(); # Compound_job_name_addFileWriteAction_body | Input to add a file write action.
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->addFileWriteAction(body => $body, simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addFileWriteAction: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Compound_job_name_addFileWriteAction_body | Input to add a file write action.
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Add a file write action to compound job.
    api_response = api_instance.add_file_write_action(body, simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addFileWriteAction: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


addInputFile

Add an input file to a task


/simulation/{simid}/workflows/{workflow_name}/tasks/{tid}/addInputFile

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/workflows/{workflow_name}/tasks/{tid}/addInputFile"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Tid_addInputFile_body body = ; // Tid_addInputFile_body | Input file.
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        String tid = tid_example; // String | ID of the task
        try {
            GenericResponse result = apiInstance.addInputFile(body, simid, workflowName, tid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addInputFile");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Tid_addInputFile_body body = ; // Tid_addInputFile_body | Input file.
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        String tid = tid_example; // String | ID of the task
        try {
            GenericResponse result = apiInstance.addInputFile(body, simid, workflowName, tid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addInputFile");
            e.printStackTrace();
        }
    }
}
Tid_addInputFile_body *body = ; // Input file.
String *simid = simid_example; // ID of the simulation
String *workflowName = workflowName_example; // 
String *tid = tid_example; // ID of the task

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Add an input file to a task
[apiInstance addInputFileWith:body
    simid:simid
    workflowName:workflowName
    tid:tid
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Tid_addInputFile_body}} Input file.
var simid = simid_example; // {{String}} ID of the simulation
var workflowName = workflowName_example; // {{String}} 
var tid = tid_example; // {{String}} ID of the task

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addInputFile(bodysimidworkflowNametid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addInputFileExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Tid_addInputFile_body(); // Tid_addInputFile_body | Input file.
            var simid = simid_example;  // String | ID of the simulation
            var workflowName = workflowName_example;  // String | 
            var tid = tid_example;  // String | ID of the task

            try
            {
                // Add an input file to a task
                GenericResponse result = apiInstance.addInputFile(body, simid, workflowName, tid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addInputFile: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Tid_addInputFile_body | Input file.
$simid = simid_example; // String | ID of the simulation
$workflowName = workflowName_example; // String | 
$tid = tid_example; // String | ID of the task

try {
    $result = $api_instance->addInputFile($body, $simid, $workflowName, $tid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->addInputFile: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Tid_addInputFile_body->new(); # Tid_addInputFile_body | Input file.
my $simid = simid_example; # String | ID of the simulation
my $workflowName = workflowName_example; # String | 
my $tid = tid_example; # String | ID of the task

eval { 
    my $result = $api_instance->addInputFile(body => $body, simid => $simid, workflowName => $workflowName, tid => $tid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addInputFile: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Tid_addInputFile_body | Input file.
simid = simid_example # String | ID of the simulation
workflowName = workflowName_example # String | 
tid = tid_example # String | ID of the task

try: 
    # Add an input file to a task
    api_response = api_instance.add_input_file(body, simid, workflowName, tid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addInputFile: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
workflow_name*
String
Required
tid*
String
ID of the task
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 404 - Task not found

Status: 405 - Invalid input


addOutputFile

Add an output file to a task


/simulation/{simid}/workflows/{workflow_name}/tasks/{tid}/addOutputFile

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/workflows/{workflow_name}/tasks/{tid}/addOutputFile"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Tid_addOutputFile_body body = ; // Tid_addOutputFile_body | Job characteristics.
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        String tid = tid_example; // String | ID of the task
        try {
            GenericResponse result = apiInstance.addOutputFile(body, simid, workflowName, tid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addOutputFile");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Tid_addOutputFile_body body = ; // Tid_addOutputFile_body | Job characteristics.
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        String tid = tid_example; // String | ID of the task
        try {
            GenericResponse result = apiInstance.addOutputFile(body, simid, workflowName, tid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addOutputFile");
            e.printStackTrace();
        }
    }
}
Tid_addOutputFile_body *body = ; // Job characteristics.
String *simid = simid_example; // ID of the simulation
String *workflowName = workflowName_example; // 
String *tid = tid_example; // ID of the task

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Add an output file to a task
[apiInstance addOutputFileWith:body
    simid:simid
    workflowName:workflowName
    tid:tid
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Tid_addOutputFile_body}} Job characteristics.
var simid = simid_example; // {{String}} ID of the simulation
var workflowName = workflowName_example; // {{String}} 
var tid = tid_example; // {{String}} ID of the task

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addOutputFile(bodysimidworkflowNametid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addOutputFileExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Tid_addOutputFile_body(); // Tid_addOutputFile_body | Job characteristics.
            var simid = simid_example;  // String | ID of the simulation
            var workflowName = workflowName_example;  // String | 
            var tid = tid_example;  // String | ID of the task

            try
            {
                // Add an output file to a task
                GenericResponse result = apiInstance.addOutputFile(body, simid, workflowName, tid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addOutputFile: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Tid_addOutputFile_body | Job characteristics.
$simid = simid_example; // String | ID of the simulation
$workflowName = workflowName_example; // String | 
$tid = tid_example; // String | ID of the task

try {
    $result = $api_instance->addOutputFile($body, $simid, $workflowName, $tid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->addOutputFile: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Tid_addOutputFile_body->new(); # Tid_addOutputFile_body | Job characteristics.
my $simid = simid_example; # String | ID of the simulation
my $workflowName = workflowName_example; # String | 
my $tid = tid_example; # String | ID of the task

eval { 
    my $result = $api_instance->addOutputFile(body => $body, simid => $simid, workflowName => $workflowName, tid => $tid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addOutputFile: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Tid_addOutputFile_body | Job characteristics.
simid = simid_example # String | ID of the simulation
workflowName = workflowName_example # String | 
tid = tid_example # String | ID of the task

try: 
    # Add an output file to a task
    api_response = api_instance.add_output_file(body, simid, workflowName, tid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addOutputFile: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
workflow_name*
String
Required
tid*
String
ID of the task
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 404 - Task not found

Status: 405 - Invalid input


addParentJob

Add parent compound job to compound job


/simulation/{simid}/compoundJobs/{compound_job_name}/addParentJob

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/addParentJob"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Compound_job_name_addParentJob_body body = ; // Compound_job_name_addParentJob_body | Input to add a parent compound job.
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            GenericResponse result = apiInstance.addParentJob(body, simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addParentJob");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Compound_job_name_addParentJob_body body = ; // Compound_job_name_addParentJob_body | Input to add a parent compound job.
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            GenericResponse result = apiInstance.addParentJob(body, simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addParentJob");
            e.printStackTrace();
        }
    }
}
Compound_job_name_addParentJob_body *body = ; // Input to add a parent compound job.
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Add parent compound job to compound job
[apiInstance addParentJobWith:body
    simid:simid
    compoundJobName:compoundJobName
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Compound_job_name_addParentJob_body}} Input to add a parent compound job.
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addParentJob(bodysimidcompoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addParentJobExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Compound_job_name_addParentJob_body(); // Compound_job_name_addParentJob_body | Input to add a parent compound job.
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Add parent compound job to compound job
                GenericResponse result = apiInstance.addParentJob(body, simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addParentJob: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Compound_job_name_addParentJob_body | Input to add a parent compound job.
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->addParentJob($body, $simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->addParentJob: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Compound_job_name_addParentJob_body->new(); # Compound_job_name_addParentJob_body | Input to add a parent compound job.
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->addParentJob(body => $body, simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addParentJob: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Compound_job_name_addParentJob_body | Input to add a parent compound job.
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Add parent compound job to compound job
    api_response = api_instance.add_parent_job(body, simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addParentJob: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


addSimpleStorageService

Create and start a simple storage service.


/simulation/{simid}/addSimpleStorageService

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/addSimpleStorageService"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addSimpleStorageService_body body = ; // Simid_addSimpleStorageService_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.addSimpleStorageService(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addSimpleStorageService");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_addSimpleStorageService_body body = ; // Simid_addSimpleStorageService_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            ServiceResponse result = apiInstance.addSimpleStorageService(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addSimpleStorageService");
            e.printStackTrace();
        }
    }
}
Simid_addSimpleStorageService_body *body = ; // Input to start a new service.
String *simid = simid_example; // ID of the simulation

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Create and start a simple storage service.
[apiInstance addSimpleStorageServiceWith:body
    simid:simid
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_addSimpleStorageService_body}} Input to start a new service.
var simid = simid_example; // {{String}} ID of the simulation

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addSimpleStorageService(bodysimid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addSimpleStorageServiceExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Simid_addSimpleStorageService_body(); // Simid_addSimpleStorageService_body | Input to start a new service.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Create and start a simple storage service.
                ServiceResponse result = apiInstance.addSimpleStorageService(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addSimpleStorageService: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_addSimpleStorageService_body | Input to start a new service.
$simid = simid_example; // String | ID of the simulation

try {
    $result = $api_instance->addSimpleStorageService($body, $simid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->addSimpleStorageService: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_addSimpleStorageService_body->new(); # Simid_addSimpleStorageService_body | Input to start a new service.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->addSimpleStorageService(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addSimpleStorageService: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Simid_addSimpleStorageService_body | Input to start a new service.
simid = simid_example # String | ID of the simulation

try: 
    # Create and start a simple storage service.
    api_response = api_instance.add_simple_storage_service(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addSimpleStorageService: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 405 - Invalid input


addSleepAction

Add a sleep action to compound job


/simulation/{simid}/compoundJobs/{compound_job_name}/addSleepAction

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/addSleepAction"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Compound_job_name_addSleepAction_body body = ; // Compound_job_name_addSleepAction_body | Input to add a sleep action.
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            GenericResponse result = apiInstance.addSleepAction(body, simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addSleepAction");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Compound_job_name_addSleepAction_body body = ; // Compound_job_name_addSleepAction_body | Input to add a sleep action.
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            GenericResponse result = apiInstance.addSleepAction(body, simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#addSleepAction");
            e.printStackTrace();
        }
    }
}
Compound_job_name_addSleepAction_body *body = ; // Input to add a sleep action.
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Add a sleep action to compound job
[apiInstance addSleepActionWith:body
    simid:simid
    compoundJobName:compoundJobName
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Compound_job_name_addSleepAction_body}} Input to add a sleep action.
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addSleepAction(bodysimidcompoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addSleepActionExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Compound_job_name_addSleepAction_body(); // Compound_job_name_addSleepAction_body | Input to add a sleep action.
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Add a sleep action to compound job
                GenericResponse result = apiInstance.addSleepAction(body, simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.addSleepAction: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Compound_job_name_addSleepAction_body | Input to add a sleep action.
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->addSleepAction($body, $simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->addSleepAction: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Compound_job_name_addSleepAction_body->new(); # Compound_job_name_addSleepAction_body | Input to add a sleep action.
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->addSleepAction(body => $body, simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->addSleepAction: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Compound_job_name_addSleepAction_body | Input to add a sleep action.
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Add a sleep action to compound job
    api_response = api_instance.add_sleep_action(body, simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->addSleepAction: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


advanceTime

Retrieve the current simulated time.


/simulation/{simid}/advanceTime

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/advanceTime"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_advanceTime_body body = ; // Simid_advanceTime_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            GenericResponse result = apiInstance.advanceTime(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#advanceTime");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_advanceTime_body body = ; // Simid_advanceTime_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        try {
            GenericResponse result = apiInstance.advanceTime(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#advanceTime");
            e.printStackTrace();
        }
    }
}
Simid_advanceTime_body *body = ; // Input to start a new service.
String *simid = simid_example; // ID of the simulation

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Retrieve the current simulated time.
[apiInstance advanceTimeWith:body
    simid:simid
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_advanceTime_body}} Input to start a new service.
var simid = simid_example; // {{String}} ID of the simulation

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.advanceTime(bodysimid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class advanceTimeExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Simid_advanceTime_body(); // Simid_advanceTime_body | Input to start a new service.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Retrieve the current simulated time.
                GenericResponse result = apiInstance.advanceTime(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.advanceTime: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_advanceTime_body | Input to start a new service.
$simid = simid_example; // String | ID of the simulation

try {
    $result = $api_instance->advanceTime($body, $simid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->advanceTime: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_advanceTime_body->new(); # Simid_advanceTime_body | Input to start a new service.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->advanceTime(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->advanceTime: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Simid_advanceTime_body | Input to start a new service.
simid = simid_example # String | ID of the simulation

try: 
    # Retrieve the current simulated time.
    api_response = api_instance.advance_time(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->advanceTime: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 405 - Invalid input


createCompoundJob

Create a new compound job.


/simulation/{simid}/createCompoundJob

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/createCompoundJob"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_createCompoundJob_body body = ; // Simid_createCompoundJob_body | Input to create a new compound job
        String simid = simid_example; // String | ID of the simulation
        try {
            GenericResponse result = apiInstance.createCompoundJob(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createCompoundJob");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_createCompoundJob_body body = ; // Simid_createCompoundJob_body | Input to create a new compound job
        String simid = simid_example; // String | ID of the simulation
        try {
            GenericResponse result = apiInstance.createCompoundJob(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createCompoundJob");
            e.printStackTrace();
        }
    }
}
Simid_createCompoundJob_body *body = ; // Input to create a new compound job
String *simid = simid_example; // ID of the simulation

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Create a new compound job.
[apiInstance createCompoundJobWith:body
    simid:simid
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_createCompoundJob_body}} Input to create a new compound job
var simid = simid_example; // {{String}} ID of the simulation

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createCompoundJob(bodysimid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createCompoundJobExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Simid_createCompoundJob_body(); // Simid_createCompoundJob_body | Input to create a new compound job
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Create a new compound job.
                GenericResponse result = apiInstance.createCompoundJob(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.createCompoundJob: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_createCompoundJob_body | Input to create a new compound job
$simid = simid_example; // String | ID of the simulation

try {
    $result = $api_instance->createCompoundJob($body, $simid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->createCompoundJob: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_createCompoundJob_body->new(); # Simid_createCompoundJob_body | Input to create a new compound job
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->createCompoundJob(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->createCompoundJob: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Simid_createCompoundJob_body | Input to create a new compound job
simid = simid_example # String | ID of the simulation

try: 
    # Create a new compound job.
    api_response = api_instance.create_compound_job(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->createCompoundJob: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 405 - Invalid input


createFileCopyAtStorageService

Create, ex nihilo, a copy of a file copy at a storage service.


/simulation/{simid}/storage_services/{service_name}/createFileCopy

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/storage_services/{service_name}/createFileCopy"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Service_name_createFileCopy_body body = ; // Service_name_createFileCopy_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The storage service name
        try {
            GenericResponse result = apiInstance.createFileCopyAtStorageService(body, simid, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createFileCopyAtStorageService");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Service_name_createFileCopy_body body = ; // Service_name_createFileCopy_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The storage service name
        try {
            GenericResponse result = apiInstance.createFileCopyAtStorageService(body, simid, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createFileCopyAtStorageService");
            e.printStackTrace();
        }
    }
}
Service_name_createFileCopy_body *body = ; // Input to start a new service.
String *simid = simid_example; // ID of the simulation
String *serviceName = serviceName_example; // The storage service name

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Create, ex nihilo, a copy of a file copy at a storage service.
[apiInstance createFileCopyAtStorageServiceWith:body
    simid:simid
    serviceName:serviceName
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Service_name_createFileCopy_body}} Input to start a new service.
var simid = simid_example; // {{String}} ID of the simulation
var serviceName = serviceName_example; // {{String}} The storage service name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createFileCopyAtStorageService(bodysimidserviceName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createFileCopyAtStorageServiceExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Service_name_createFileCopy_body(); // Service_name_createFileCopy_body | Input to start a new service.
            var simid = simid_example;  // String | ID of the simulation
            var serviceName = serviceName_example;  // String | The storage service name

            try
            {
                // Create, ex nihilo, a copy of a file copy at a storage service.
                GenericResponse result = apiInstance.createFileCopyAtStorageService(body, simid, serviceName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.createFileCopyAtStorageService: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Service_name_createFileCopy_body | Input to start a new service.
$simid = simid_example; // String | ID of the simulation
$serviceName = serviceName_example; // String | The storage service name

try {
    $result = $api_instance->createFileCopyAtStorageService($body, $simid, $serviceName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->createFileCopyAtStorageService: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Service_name_createFileCopy_body->new(); # Service_name_createFileCopy_body | Input to start a new service.
my $simid = simid_example; # String | ID of the simulation
my $serviceName = serviceName_example; # String | The storage service name

eval { 
    my $result = $api_instance->createFileCopyAtStorageService(body => $body, simid => $simid, serviceName => $serviceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->createFileCopyAtStorageService: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Service_name_createFileCopy_body | Input to start a new service.
simid = simid_example # String | ID of the simulation
serviceName = serviceName_example # String | The storage service name

try: 
    # Create, ex nihilo, a copy of a file copy at a storage service.
    api_response = api_instance.create_file_copy_at_storage_service(body, simid, serviceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->createFileCopyAtStorageService: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
service_name*
String
The storage service name
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 404 - Simulation or storage service not found

Status: 405 - Invalid input


createStandardJob

Create a new standard job.


/simulation/{simid}/workflows/{workflow_name}/createStandardJob

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/workflows/{workflow_name}/createStandardJob"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        StandardJob body = ; // StandardJob | Job specification.
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        try {
            JobResponse result = apiInstance.createStandardJob(body, simid, workflowName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createStandardJob");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        StandardJob body = ; // StandardJob | Job specification.
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        try {
            JobResponse result = apiInstance.createStandardJob(body, simid, workflowName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createStandardJob");
            e.printStackTrace();
        }
    }
}
StandardJob *body = ; // Job specification.
String *simid = simid_example; // ID of the simulation
String *workflowName = workflowName_example; // 

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Create a new standard job.
[apiInstance createStandardJobWith:body
    simid:simid
    workflowName:workflowName
              completionHandler: ^(JobResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{StandardJob}} Job specification.
var simid = simid_example; // {{String}} ID of the simulation
var workflowName = workflowName_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createStandardJob(bodysimidworkflowName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createStandardJobExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new StandardJob(); // StandardJob | Job specification.
            var simid = simid_example;  // String | ID of the simulation
            var workflowName = workflowName_example;  // String | 

            try
            {
                // Create a new standard job.
                JobResponse result = apiInstance.createStandardJob(body, simid, workflowName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.createStandardJob: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // StandardJob | Job specification.
$simid = simid_example; // String | ID of the simulation
$workflowName = workflowName_example; // String | 

try {
    $result = $api_instance->createStandardJob($body, $simid, $workflowName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->createStandardJob: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::StandardJob->new(); # StandardJob | Job specification.
my $simid = simid_example; # String | ID of the simulation
my $workflowName = workflowName_example; # String | 

eval { 
    my $result = $api_instance->createStandardJob(body => $body, simid => $simid, workflowName => $workflowName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->createStandardJob: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # StandardJob | Job specification.
simid = simid_example # String | ID of the simulation
workflowName = workflowName_example # String | 

try: 
    # Create a new standard job.
    api_response = api_instance.create_standard_job(body, simid, workflowName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->createStandardJob: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
workflow_name*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 405 - Invalid input


createTask

Create a new task.


/simulation/{simid}/workflows/{workflow_name}/createTask

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/workflows/{workflow_name}/createTask"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Task body = ; // Task | Task characteristics.
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        try {
            GenericResponse result = apiInstance.createTask(body, simid, workflowName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createTask");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Task body = ; // Task | Task characteristics.
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        try {
            GenericResponse result = apiInstance.createTask(body, simid, workflowName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createTask");
            e.printStackTrace();
        }
    }
}
Task *body = ; // Task characteristics.
String *simid = simid_example; // ID of the simulation
String *workflowName = workflowName_example; // 

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Create a new task.
[apiInstance createTaskWith:body
    simid:simid
    workflowName:workflowName
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Task}} Task characteristics.
var simid = simid_example; // {{String}} ID of the simulation
var workflowName = workflowName_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createTask(bodysimidworkflowName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createTaskExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Task(); // Task | Task characteristics.
            var simid = simid_example;  // String | ID of the simulation
            var workflowName = workflowName_example;  // String | 

            try
            {
                // Create a new task.
                GenericResponse result = apiInstance.createTask(body, simid, workflowName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.createTask: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Task | Task characteristics.
$simid = simid_example; // String | ID of the simulation
$workflowName = workflowName_example; // String | 

try {
    $result = $api_instance->createTask($body, $simid, $workflowName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->createTask: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Task->new(); # Task | Task characteristics.
my $simid = simid_example; # String | ID of the simulation
my $workflowName = workflowName_example; # String | 

eval { 
    my $result = $api_instance->createTask(body => $body, simid => $simid, workflowName => $workflowName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->createTask: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Task | Task characteristics.
simid = simid_example # String | ID of the simulation
workflowName = workflowName_example # String | 

try: 
    # Create a new task.
    api_response = api_instance.create_task(body, simid, workflowName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->createTask: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
workflow_name*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 405 - Invalid input


createVM

Create a VM on a cloud compute service.


/simulation/{simid}/cloud_compute_services/{service_name}/createVM

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/cloud_compute_services/{service_name}/createVM"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Service_name_createVM_body body = ; // Service_name_createVM_body | Input to start create a VM.
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The cloud compute service name
        try {
            VMCreationResponse result = apiInstance.createVM(body, simid, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createVM");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Service_name_createVM_body body = ; // Service_name_createVM_body | Input to start create a VM.
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The cloud compute service name
        try {
            VMCreationResponse result = apiInstance.createVM(body, simid, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createVM");
            e.printStackTrace();
        }
    }
}
Service_name_createVM_body *body = ; // Input to start create a VM.
String *simid = simid_example; // ID of the simulation
String *serviceName = serviceName_example; // The cloud compute service name

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Create a VM on a cloud compute service.
[apiInstance createVMWith:body
    simid:simid
    serviceName:serviceName
              completionHandler: ^(VMCreationResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Service_name_createVM_body}} Input to start create a VM.
var simid = simid_example; // {{String}} ID of the simulation
var serviceName = serviceName_example; // {{String}} The cloud compute service name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createVM(bodysimidserviceName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createVMExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Service_name_createVM_body(); // Service_name_createVM_body | Input to start create a VM.
            var simid = simid_example;  // String | ID of the simulation
            var serviceName = serviceName_example;  // String | The cloud compute service name

            try
            {
                // Create a VM on a cloud compute service.
                VMCreationResponse result = apiInstance.createVM(body, simid, serviceName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.createVM: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Service_name_createVM_body | Input to start create a VM.
$simid = simid_example; // String | ID of the simulation
$serviceName = serviceName_example; // String | The cloud compute service name

try {
    $result = $api_instance->createVM($body, $simid, $serviceName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->createVM: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Service_name_createVM_body->new(); # Service_name_createVM_body | Input to start create a VM.
my $simid = simid_example; # String | ID of the simulation
my $serviceName = serviceName_example; # String | The cloud compute service name

eval { 
    my $result = $api_instance->createVM(body => $body, simid => $simid, serviceName => $serviceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->createVM: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Service_name_createVM_body | Input to start create a VM.
simid = simid_example # String | ID of the simulation
serviceName = serviceName_example # String | The cloud compute service name

try: 
    # Create a VM on a cloud compute service.
    api_response = api_instance.create_vm(body, simid, serviceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->createVM: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
service_name*
String
The cloud compute service name
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 405 - Invalid input


createWorkflow

Create a blank workflow.


/simulation/{simid}/createWorkflow

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/createWorkflow"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        try {
            WorkflowResponse result = apiInstance.createWorkflow(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createWorkflow");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        try {
            WorkflowResponse result = apiInstance.createWorkflow(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createWorkflow");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Create a blank workflow.
[apiInstance createWorkflowWith:simid
              completionHandler: ^(WorkflowResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createWorkflow(simid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createWorkflowExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Create a blank workflow.
                WorkflowResponse result = apiInstance.createWorkflow(simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.createWorkflow: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation

try {
    $result = $api_instance->createWorkflow($simid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->createWorkflow: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->createWorkflow(simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->createWorkflow: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation

try: 
    # Create a blank workflow.
    api_response = api_instance.create_workflow(simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->createWorkflow: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


createWorkflowFromJSON

Create a workflow from a WfCommons JSON object.


/simulation/{simid}/createWorkflowFromJSON

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/createWorkflowFromJSON"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_createWorkflowFromJSON_body body = ; // Simid_createWorkflowFromJSON_body | Input to create workflow from JSON.
        String simid = simid_example; // String | ID of the simulation
        try {
            WorkflowResponseWithTaskAndFileList result = apiInstance.createWorkflowFromJSON(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createWorkflowFromJSON");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Simid_createWorkflowFromJSON_body body = ; // Simid_createWorkflowFromJSON_body | Input to create workflow from JSON.
        String simid = simid_example; // String | ID of the simulation
        try {
            WorkflowResponseWithTaskAndFileList result = apiInstance.createWorkflowFromJSON(body, simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#createWorkflowFromJSON");
            e.printStackTrace();
        }
    }
}
Simid_createWorkflowFromJSON_body *body = ; // Input to create workflow from JSON.
String *simid = simid_example; // ID of the simulation

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Create a workflow from a WfCommons JSON object.
[apiInstance createWorkflowFromJSONWith:body
    simid:simid
              completionHandler: ^(WorkflowResponseWithTaskAndFileList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Simid_createWorkflowFromJSON_body}} Input to create workflow from JSON.
var simid = simid_example; // {{String}} ID of the simulation

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createWorkflowFromJSON(bodysimid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createWorkflowFromJSONExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Simid_createWorkflowFromJSON_body(); // Simid_createWorkflowFromJSON_body | Input to create workflow from JSON.
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Create a workflow from a WfCommons JSON object.
                WorkflowResponseWithTaskAndFileList result = apiInstance.createWorkflowFromJSON(body, simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.createWorkflowFromJSON: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Simid_createWorkflowFromJSON_body | Input to create workflow from JSON.
$simid = simid_example; // String | ID of the simulation

try {
    $result = $api_instance->createWorkflowFromJSON($body, $simid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->createWorkflowFromJSON: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Simid_createWorkflowFromJSON_body->new(); # Simid_createWorkflowFromJSON_body | Input to create workflow from JSON.
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->createWorkflowFromJSON(body => $body, simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->createWorkflowFromJSON: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Simid_createWorkflowFromJSON_body | Input to create workflow from JSON.
simid = simid_example # String | ID of the simulation

try: 
    # Create a workflow from a WfCommons JSON object.
    api_response = api_instance.create_workflow_from_json(body, simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->createWorkflowFromJSON: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 405 - Invalid input


destroyVM

Destroy a VM.


/simulation/{simid}/cloud_compute_services/{service_name}/vms/{vm_name}/destroyVM

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/cloud_compute_services/{service_name}/vms/{vm_name}/destroyVM"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The cloud compute service name
        String vmName = vmName_example; // String | The VM name
        try {
            GenericResponse result = apiInstance.destroyVM(simid, serviceName, vmName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#destroyVM");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The cloud compute service name
        String vmName = vmName_example; // String | The VM name
        try {
            GenericResponse result = apiInstance.destroyVM(simid, serviceName, vmName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#destroyVM");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *serviceName = serviceName_example; // The cloud compute service name
String *vmName = vmName_example; // The VM name

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Destroy a VM.
[apiInstance destroyVMWith:simid
    serviceName:serviceName
    vmName:vmName
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var serviceName = serviceName_example; // {{String}} The cloud compute service name
var vmName = vmName_example; // {{String}} The VM name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.destroyVM(simid, serviceName, vmName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class destroyVMExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var serviceName = serviceName_example;  // String | The cloud compute service name
            var vmName = vmName_example;  // String | The VM name

            try
            {
                // Destroy a VM.
                GenericResponse result = apiInstance.destroyVM(simid, serviceName, vmName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.destroyVM: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$serviceName = serviceName_example; // String | The cloud compute service name
$vmName = vmName_example; // String | The VM name

try {
    $result = $api_instance->destroyVM($simid, $serviceName, $vmName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->destroyVM: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $serviceName = serviceName_example; # String | The cloud compute service name
my $vmName = vmName_example; # String | The VM name

eval { 
    my $result = $api_instance->destroyVM(simid => $simid, serviceName => $serviceName, vmName => $vmName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->destroyVM: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
serviceName = serviceName_example # String | The cloud compute service name
vmName = vmName_example # String | The VM name

try: 
    # Destroy a VM.
    api_response = api_instance.destroy_vm(simid, serviceName, vmName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->destroyVM: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
service_name*
String
The cloud compute service name
Required
vm_name*
String
The VM name
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


fileRegistryServiceAddEntry

Add an entry to a file registry service.


/simulation/{simid}/fileRegistryServices/{file_registry_service_name}/addEntry

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/fileRegistryServices/{file_registry_service_name}/addEntry"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        FileRegistryServiceEntry body = ; // FileRegistryServiceEntry | Entry to add.
        String simid = simid_example; // String | ID of the simulation
        String fileRegistryServiceName = fileRegistryServiceName_example; // String | 
        try {
            GenericResponse result = apiInstance.fileRegistryServiceAddEntry(body, simid, fileRegistryServiceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#fileRegistryServiceAddEntry");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        FileRegistryServiceEntry body = ; // FileRegistryServiceEntry | Entry to add.
        String simid = simid_example; // String | ID of the simulation
        String fileRegistryServiceName = fileRegistryServiceName_example; // String | 
        try {
            GenericResponse result = apiInstance.fileRegistryServiceAddEntry(body, simid, fileRegistryServiceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#fileRegistryServiceAddEntry");
            e.printStackTrace();
        }
    }
}
FileRegistryServiceEntry *body = ; // Entry to add.
String *simid = simid_example; // ID of the simulation
String *fileRegistryServiceName = fileRegistryServiceName_example; // 

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Add an entry to a file registry service.
[apiInstance fileRegistryServiceAddEntryWith:body
    simid:simid
    fileRegistryServiceName:fileRegistryServiceName
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{FileRegistryServiceEntry}} Entry to add.
var simid = simid_example; // {{String}} ID of the simulation
var fileRegistryServiceName = fileRegistryServiceName_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.fileRegistryServiceAddEntry(bodysimidfileRegistryServiceName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class fileRegistryServiceAddEntryExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new FileRegistryServiceEntry(); // FileRegistryServiceEntry | Entry to add.
            var simid = simid_example;  // String | ID of the simulation
            var fileRegistryServiceName = fileRegistryServiceName_example;  // String | 

            try
            {
                // Add an entry to a file registry service.
                GenericResponse result = apiInstance.fileRegistryServiceAddEntry(body, simid, fileRegistryServiceName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.fileRegistryServiceAddEntry: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // FileRegistryServiceEntry | Entry to add.
$simid = simid_example; // String | ID of the simulation
$fileRegistryServiceName = fileRegistryServiceName_example; // String | 

try {
    $result = $api_instance->fileRegistryServiceAddEntry($body, $simid, $fileRegistryServiceName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->fileRegistryServiceAddEntry: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::FileRegistryServiceEntry->new(); # FileRegistryServiceEntry | Entry to add.
my $simid = simid_example; # String | ID of the simulation
my $fileRegistryServiceName = fileRegistryServiceName_example; # String | 

eval { 
    my $result = $api_instance->fileRegistryServiceAddEntry(body => $body, simid => $simid, fileRegistryServiceName => $fileRegistryServiceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->fileRegistryServiceAddEntry: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # FileRegistryServiceEntry | Entry to add.
simid = simid_example # String | ID of the simulation
fileRegistryServiceName = fileRegistryServiceName_example # String | 

try: 
    # Add an entry to a file registry service.
    api_response = api_instance.file_registry_service_add_entry(body, simid, fileRegistryServiceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->fileRegistryServiceAddEntry: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
file_registry_service_name*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 405 - Invalid input


fileRegistryServiceLookUpEntry

Look up the locations of file.


/simulation/{simid}/fileRegistryServices/{file_registry_service_name}/lookupEntry

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/fileRegistryServices/{file_registry_service_name}/lookupEntry"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        File_registry_service_name_lookupEntry_body body = ; // File_registry_service_name_lookupEntry_body | File to lookup.
        String simid = simid_example; // String | ID of the simulation
        String fileRegistryServiceName = fileRegistryServiceName_example; // String | 
        try {
            StorageServiceList result = apiInstance.fileRegistryServiceLookUpEntry(body, simid, fileRegistryServiceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#fileRegistryServiceLookUpEntry");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        File_registry_service_name_lookupEntry_body body = ; // File_registry_service_name_lookupEntry_body | File to lookup.
        String simid = simid_example; // String | ID of the simulation
        String fileRegistryServiceName = fileRegistryServiceName_example; // String | 
        try {
            StorageServiceList result = apiInstance.fileRegistryServiceLookUpEntry(body, simid, fileRegistryServiceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#fileRegistryServiceLookUpEntry");
            e.printStackTrace();
        }
    }
}
File_registry_service_name_lookupEntry_body *body = ; // File to lookup.
String *simid = simid_example; // ID of the simulation
String *fileRegistryServiceName = fileRegistryServiceName_example; // 

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Look up the locations of file.
[apiInstance fileRegistryServiceLookUpEntryWith:body
    simid:simid
    fileRegistryServiceName:fileRegistryServiceName
              completionHandler: ^(StorageServiceList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{File_registry_service_name_lookupEntry_body}} File to lookup.
var simid = simid_example; // {{String}} ID of the simulation
var fileRegistryServiceName = fileRegistryServiceName_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.fileRegistryServiceLookUpEntry(bodysimidfileRegistryServiceName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class fileRegistryServiceLookUpEntryExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new File_registry_service_name_lookupEntry_body(); // File_registry_service_name_lookupEntry_body | File to lookup.
            var simid = simid_example;  // String | ID of the simulation
            var fileRegistryServiceName = fileRegistryServiceName_example;  // String | 

            try
            {
                // Look up the locations of file.
                StorageServiceList result = apiInstance.fileRegistryServiceLookUpEntry(body, simid, fileRegistryServiceName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.fileRegistryServiceLookUpEntry: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // File_registry_service_name_lookupEntry_body | File to lookup.
$simid = simid_example; // String | ID of the simulation
$fileRegistryServiceName = fileRegistryServiceName_example; // String | 

try {
    $result = $api_instance->fileRegistryServiceLookUpEntry($body, $simid, $fileRegistryServiceName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->fileRegistryServiceLookUpEntry: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::File_registry_service_name_lookupEntry_body->new(); # File_registry_service_name_lookupEntry_body | File to lookup.
my $simid = simid_example; # String | ID of the simulation
my $fileRegistryServiceName = fileRegistryServiceName_example; # String | 

eval { 
    my $result = $api_instance->fileRegistryServiceLookUpEntry(body => $body, simid => $simid, fileRegistryServiceName => $fileRegistryServiceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->fileRegistryServiceLookUpEntry: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # File_registry_service_name_lookupEntry_body | File to lookup.
simid = simid_example # String | ID of the simulation
fileRegistryServiceName = fileRegistryServiceName_example # String | 

try: 
    # Look up the locations of file.
    api_response = api_instance.file_registry_service_look_up_entry(body, simid, fileRegistryServiceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->fileRegistryServiceLookUpEntry: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
file_registry_service_name*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 404 - Task not found

Status: 405 - Invalid input


fileRegistryServiceRemoveEntry

Remove an entry from a file registry service.


/simulation/{simid}/fileRegistryServices/{file_registry_service_name}/removeEntry

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/fileRegistryServices/{file_registry_service_name}/removeEntry"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        FileRegistryServiceEntry body = ; // FileRegistryServiceEntry | Entry to remove.
        String simid = simid_example; // String | ID of the simulation
        String fileRegistryServiceName = fileRegistryServiceName_example; // String | name of the file registry service
        try {
            GenericResponse result = apiInstance.fileRegistryServiceRemoveEntry(body, simid, fileRegistryServiceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#fileRegistryServiceRemoveEntry");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        FileRegistryServiceEntry body = ; // FileRegistryServiceEntry | Entry to remove.
        String simid = simid_example; // String | ID of the simulation
        String fileRegistryServiceName = fileRegistryServiceName_example; // String | name of the file registry service
        try {
            GenericResponse result = apiInstance.fileRegistryServiceRemoveEntry(body, simid, fileRegistryServiceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#fileRegistryServiceRemoveEntry");
            e.printStackTrace();
        }
    }
}
FileRegistryServiceEntry *body = ; // Entry to remove.
String *simid = simid_example; // ID of the simulation
String *fileRegistryServiceName = fileRegistryServiceName_example; // name of the file registry service

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Remove an entry from a file registry service.
[apiInstance fileRegistryServiceRemoveEntryWith:body
    simid:simid
    fileRegistryServiceName:fileRegistryServiceName
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{FileRegistryServiceEntry}} Entry to remove.
var simid = simid_example; // {{String}} ID of the simulation
var fileRegistryServiceName = fileRegistryServiceName_example; // {{String}} name of the file registry service

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.fileRegistryServiceRemoveEntry(bodysimidfileRegistryServiceName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class fileRegistryServiceRemoveEntryExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new FileRegistryServiceEntry(); // FileRegistryServiceEntry | Entry to remove.
            var simid = simid_example;  // String | ID of the simulation
            var fileRegistryServiceName = fileRegistryServiceName_example;  // String | name of the file registry service

            try
            {
                // Remove an entry from a file registry service.
                GenericResponse result = apiInstance.fileRegistryServiceRemoveEntry(body, simid, fileRegistryServiceName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.fileRegistryServiceRemoveEntry: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // FileRegistryServiceEntry | Entry to remove.
$simid = simid_example; // String | ID of the simulation
$fileRegistryServiceName = fileRegistryServiceName_example; // String | name of the file registry service

try {
    $result = $api_instance->fileRegistryServiceRemoveEntry($body, $simid, $fileRegistryServiceName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->fileRegistryServiceRemoveEntry: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::FileRegistryServiceEntry->new(); # FileRegistryServiceEntry | Entry to remove.
my $simid = simid_example; # String | ID of the simulation
my $fileRegistryServiceName = fileRegistryServiceName_example; # String | name of the file registry service

eval { 
    my $result = $api_instance->fileRegistryServiceRemoveEntry(body => $body, simid => $simid, fileRegistryServiceName => $fileRegistryServiceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->fileRegistryServiceRemoveEntry: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # FileRegistryServiceEntry | Entry to remove.
simid = simid_example # String | ID of the simulation
fileRegistryServiceName = fileRegistryServiceName_example # String | name of the file registry service

try: 
    # Remove an entry from a file registry service.
    api_response = api_instance.file_registry_service_remove_entry(body, simid, fileRegistryServiceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->fileRegistryServiceRemoveEntry: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
file_registry_service_name*
String
name of the file registry service
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 405 - Invalid input


getAllHostnames

Retrieve the names of all hosts in the simulated platform.


/simulation/{simid}/hostnames

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/hostnames"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of simulation
        try {
            HostnameList result = apiInstance.getAllHostnames(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getAllHostnames");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of simulation
        try {
            HostnameList result = apiInstance.getAllHostnames(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getAllHostnames");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of simulation

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Retrieve the names of all hosts in the simulated platform.
[apiInstance getAllHostnamesWith:simid
              completionHandler: ^(HostnameList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of simulation

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllHostnames(simid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getAllHostnamesExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of simulation

            try
            {
                // Retrieve the names of all hosts in the simulated platform.
                HostnameList result = apiInstance.getAllHostnames(simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getAllHostnames: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of simulation

try {
    $result = $api_instance->getAllHostnames($simid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getAllHostnames: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of simulation

eval { 
    my $result = $api_instance->getAllHostnames(simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getAllHostnames: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of simulation

try: 
    # Retrieve the names of all hosts in the simulated platform.
    api_response = api_instance.get_all_hostnames(simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getAllHostnames: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of simulation
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


getCoreCounts

Returns the core counts for each host managed by the compute service.


/simulation/{simid}/compute_services/{service_name}/coreCounts

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compute_services/{service_name}/coreCounts"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The compute service name
        try {
            inline_response_200_1 result = apiInstance.getCoreCounts(simid, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getCoreCounts");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The compute service name
        try {
            inline_response_200_1 result = apiInstance.getCoreCounts(simid, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getCoreCounts");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *serviceName = serviceName_example; // The compute service name

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Returns the core counts for each host managed by the compute service.
[apiInstance getCoreCountsWith:simid
    serviceName:serviceName
              completionHandler: ^(inline_response_200_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var serviceName = serviceName_example; // {{String}} The compute service name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getCoreCounts(simid, serviceName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getCoreCountsExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var serviceName = serviceName_example;  // String | The compute service name

            try
            {
                // Returns the core counts for each host managed by the compute service.
                inline_response_200_1 result = apiInstance.getCoreCounts(simid, serviceName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getCoreCounts: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$serviceName = serviceName_example; // String | The compute service name

try {
    $result = $api_instance->getCoreCounts($simid, $serviceName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getCoreCounts: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $serviceName = serviceName_example; # String | The compute service name

eval { 
    my $result = $api_instance->getCoreCounts(simid => $simid, serviceName => $serviceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getCoreCounts: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
serviceName = serviceName_example # String | The compute service name

try: 
    # Returns the core counts for each host managed by the compute service.
    api_response = api_instance.get_core_counts(simid, serviceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getCoreCounts: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
service_name*
String
The compute service name
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


getCoreFlopRates

Returns the core flop rate for each host managed by the compute service.


/simulation/{simid}/compute_services/{service_name}/coreFlopRates

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compute_services/{service_name}/coreFlopRates"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The compute service name
        try {
            inline_response_200 result = apiInstance.getCoreFlopRates(simid, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getCoreFlopRates");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The compute service name
        try {
            inline_response_200 result = apiInstance.getCoreFlopRates(simid, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getCoreFlopRates");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *serviceName = serviceName_example; // The compute service name

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Returns the core flop rate for each host managed by the compute service.
[apiInstance getCoreFlopRatesWith:simid
    serviceName:serviceName
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var serviceName = serviceName_example; // {{String}} The compute service name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getCoreFlopRates(simid, serviceName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getCoreFlopRatesExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var serviceName = serviceName_example;  // String | The compute service name

            try
            {
                // Returns the core flop rate for each host managed by the compute service.
                inline_response_200 result = apiInstance.getCoreFlopRates(simid, serviceName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getCoreFlopRates: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$serviceName = serviceName_example; // String | The compute service name

try {
    $result = $api_instance->getCoreFlopRates($simid, $serviceName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getCoreFlopRates: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $serviceName = serviceName_example; # String | The compute service name

eval { 
    my $result = $api_instance->getCoreFlopRates(simid => $simid, serviceName => $serviceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getCoreFlopRates: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
serviceName = serviceName_example # String | The compute service name

try: 
    # Returns the core flop rate for each host managed by the compute service.
    api_response = api_instance.get_core_flop_rates(simid, serviceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getCoreFlopRates: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
service_name*
String
The compute service name
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


getExecutionHosts

Get the list of execution hosts available to run VMs.


/simulation/{simid}/getExecutionHosts

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/getExecutionHosts"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of simulation
        try {
            HostnameList result = apiInstance.getExecutionHosts(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getExecutionHosts");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of simulation
        try {
            HostnameList result = apiInstance.getExecutionHosts(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getExecutionHosts");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of simulation

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get the list of execution hosts available to run VMs.
[apiInstance getExecutionHostsWith:simid
              completionHandler: ^(HostnameList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of simulation

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getExecutionHosts(simid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getExecutionHostsExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of simulation

            try
            {
                // Get the list of execution hosts available to run VMs.
                HostnameList result = apiInstance.getExecutionHosts(simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getExecutionHosts: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of simulation

try {
    $result = $api_instance->getExecutionHosts($simid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getExecutionHosts: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of simulation

eval { 
    my $result = $api_instance->getExecutionHosts(simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getExecutionHosts: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of simulation

try: 
    # Get the list of execution hosts available to run VMs.
    api_response = api_instance.get_execution_hosts(simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getExecutionHosts: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of simulation
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


getFileSize

Get a file size.


/simulation/{simid}/files/{file_id}/size

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/files/{file_id}/size"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String fileId = fileId_example; // String | Name of the file
        try {
            FileSizeResponse result = apiInstance.getFileSize(simid, fileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getFileSize");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String fileId = fileId_example; // String | Name of the file
        try {
            FileSizeResponse result = apiInstance.getFileSize(simid, fileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getFileSize");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *fileId = fileId_example; // Name of the file

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get a file size.
[apiInstance getFileSizeWith:simid
    fileId:fileId
              completionHandler: ^(FileSizeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var fileId = fileId_example; // {{String}} Name of the file

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getFileSize(simid, fileId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getFileSizeExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var fileId = fileId_example;  // String | Name of the file

            try
            {
                // Get a file size.
                FileSizeResponse result = apiInstance.getFileSize(simid, fileId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getFileSize: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$fileId = fileId_example; // String | Name of the file

try {
    $result = $api_instance->getFileSize($simid, $fileId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getFileSize: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $fileId = fileId_example; # String | Name of the file

eval { 
    my $result = $api_instance->getFileSize(simid => $simid, fileId => $fileId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getFileSize: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
fileId = fileId_example # String | Name of the file

try: 
    # Get a file size.
    api_response = api_instance.get_file_size(simid, fileId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getFileSize: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
file_id*
String
Name of the file
Required

Responses

Status: 200 - OK

Status: 404 - File not found

Status: 405 - Invalid input


getInputFiles

Return the list of input files of the workflow.


/simulation/{simid}/workflows/{workflow_name}/inputFiles

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/workflows/{workflow_name}/inputFiles"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        try {
            FileList result = apiInstance.getInputFiles(simid, workflowName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getInputFiles");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        try {
            FileList result = apiInstance.getInputFiles(simid, workflowName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getInputFiles");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *workflowName = workflowName_example; // 

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Return the list of input files of the workflow.
[apiInstance getInputFilesWith:simid
    workflowName:workflowName
              completionHandler: ^(FileList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var workflowName = workflowName_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getInputFiles(simid, workflowName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getInputFilesExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var workflowName = workflowName_example;  // String | 

            try
            {
                // Return the list of input files of the workflow.
                FileList result = apiInstance.getInputFiles(simid, workflowName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getInputFiles: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$workflowName = workflowName_example; // String | 

try {
    $result = $api_instance->getInputFiles($simid, $workflowName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getInputFiles: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $workflowName = workflowName_example; # String | 

eval { 
    my $result = $api_instance->getInputFiles(simid => $simid, workflowName => $workflowName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getInputFiles: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
workflowName = workflowName_example # String | 

try: 
    # Return the list of input files of the workflow.
    api_response = api_instance.get_input_files(simid, workflowName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getInputFiles: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
workflow_name*
String
Required

Responses

Status: 200 - OK

Status: 404 - Task not found

Status: 405 - Invalid input


getReadyTasks

Return the list of ready tasks in the workflow.


/simulation/{simid}/workflows/{workflow_name}/readyTasks

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/workflows/{workflow_name}/readyTasks"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        try {
            TaskList result = apiInstance.getReadyTasks(simid, workflowName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getReadyTasks");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        try {
            TaskList result = apiInstance.getReadyTasks(simid, workflowName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getReadyTasks");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *workflowName = workflowName_example; // 

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Return the list of ready tasks in the workflow.
[apiInstance getReadyTasksWith:simid
    workflowName:workflowName
              completionHandler: ^(TaskList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var workflowName = workflowName_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getReadyTasks(simid, workflowName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getReadyTasksExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var workflowName = workflowName_example;  // String | 

            try
            {
                // Return the list of ready tasks in the workflow.
                TaskList result = apiInstance.getReadyTasks(simid, workflowName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getReadyTasks: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$workflowName = workflowName_example; // String | 

try {
    $result = $api_instance->getReadyTasks($simid, $workflowName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getReadyTasks: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $workflowName = workflowName_example; # String | 

eval { 
    my $result = $api_instance->getReadyTasks(simid => $simid, workflowName => $workflowName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getReadyTasks: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
workflowName = workflowName_example # String | 

try: 
    # Return the list of ready tasks in the workflow.
    api_response = api_instance.get_ready_tasks(simid, workflowName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getReadyTasks: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
workflow_name*
String
Required

Responses

Status: 200 - OK

Status: 404 - Task not found

Status: 405 - Invalid input


getSimulationEvents

Retrieve all simulation events since last time we checked.


/simulation/{simid}/simulationEvents

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/simulationEvents"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of simulation
        try {
            EventList result = apiInstance.getSimulationEvents(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getSimulationEvents");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of simulation
        try {
            EventList result = apiInstance.getSimulationEvents(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getSimulationEvents");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of simulation

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Retrieve all simulation events since last time we checked.
[apiInstance getSimulationEventsWith:simid
              completionHandler: ^(EventList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of simulation

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSimulationEvents(simid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getSimulationEventsExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of simulation

            try
            {
                // Retrieve all simulation events since last time we checked.
                EventList result = apiInstance.getSimulationEvents(simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getSimulationEvents: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of simulation

try {
    $result = $api_instance->getSimulationEvents($simid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getSimulationEvents: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of simulation

eval { 
    my $result = $api_instance->getSimulationEvents(simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getSimulationEvents: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of simulation

try: 
    # Retrieve all simulation events since last time we checked.
    api_response = api_instance.get_simulation_events(simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getSimulationEvents: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of simulation
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


getSimulationTime

Retrieve the current simulated time.


/simulation/{simid}/getTime

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/getTime"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        try {
            TimeResponse result = apiInstance.getSimulationTime(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getSimulationTime");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        try {
            TimeResponse result = apiInstance.getSimulationTime(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getSimulationTime");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Retrieve the current simulated time.
[apiInstance getSimulationTimeWith:simid
              completionHandler: ^(TimeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSimulationTime(simid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getSimulationTimeExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Retrieve the current simulated time.
                TimeResponse result = apiInstance.getSimulationTime(simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getSimulationTime: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation

try {
    $result = $api_instance->getSimulationTime($simid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getSimulationTime: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->getSimulationTime(simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getSimulationTime: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation

try: 
    # Retrieve the current simulated time.
    api_response = api_instance.get_simulation_time(simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getSimulationTime: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


getStandardJobTasks

Retrieve job's tasks


/simulation/{simid}/jobs/{job_name}/tasks

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/jobs/{job_name}/tasks"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String jobName = jobName_example; // String | ID of the job
        try {
            TaskList result = apiInstance.getStandardJobTasks(simid, jobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getStandardJobTasks");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String jobName = jobName_example; // String | ID of the job
        try {
            TaskList result = apiInstance.getStandardJobTasks(simid, jobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getStandardJobTasks");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *jobName = jobName_example; // ID of the job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Retrieve job's tasks
[apiInstance getStandardJobTasksWith:simid
    jobName:jobName
              completionHandler: ^(TaskList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var jobName = jobName_example; // {{String}} ID of the job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getStandardJobTasks(simid, jobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getStandardJobTasksExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var jobName = jobName_example;  // String | ID of the job

            try
            {
                // Retrieve job's tasks
                TaskList result = apiInstance.getStandardJobTasks(simid, jobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getStandardJobTasks: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$jobName = jobName_example; // String | ID of the job

try {
    $result = $api_instance->getStandardJobTasks($simid, $jobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getStandardJobTasks: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $jobName = jobName_example; # String | ID of the job

eval { 
    my $result = $api_instance->getStandardJobTasks(simid => $simid, jobName => $jobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getStandardJobTasks: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
jobName = jobName_example # String | ID of the job

try: 
    # Retrieve job's tasks
    api_response = api_instance.get_standard_job_tasks(simid, jobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getStandardJobTasks: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
job_name*
String
ID of the job
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskEndDate

Get a task's end date.


/simulation/{simid}/workflows/{workflow_name}/tasks/{task_name}/taskGetEndDate

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/workflows/{workflow_name}/tasks/{task_name}/taskGetEndDate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        String taskName = taskName_example; // String | Name of the task
        try {
            TimeResponse result = apiInstance.getTaskEndDate(simid, workflowName, taskName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskEndDate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        String taskName = taskName_example; // String | Name of the task
        try {
            TimeResponse result = apiInstance.getTaskEndDate(simid, workflowName, taskName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskEndDate");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *workflowName = workflowName_example; // 
String *taskName = taskName_example; // Name of the task

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get a task's end date.
[apiInstance getTaskEndDateWith:simid
    workflowName:workflowName
    taskName:taskName
              completionHandler: ^(TimeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var workflowName = workflowName_example; // {{String}} 
var taskName = taskName_example; // {{String}} Name of the task

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskEndDate(simid, workflowName, taskName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskEndDateExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var workflowName = workflowName_example;  // String | 
            var taskName = taskName_example;  // String | Name of the task

            try
            {
                // Get a task's end date.
                TimeResponse result = apiInstance.getTaskEndDate(simid, workflowName, taskName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskEndDate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$workflowName = workflowName_example; // String | 
$taskName = taskName_example; // String | Name of the task

try {
    $result = $api_instance->getTaskEndDate($simid, $workflowName, $taskName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskEndDate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $workflowName = workflowName_example; # String | 
my $taskName = taskName_example; # String | Name of the task

eval { 
    my $result = $api_instance->getTaskEndDate(simid => $simid, workflowName => $workflowName, taskName => $taskName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskEndDate: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
workflowName = workflowName_example # String | 
taskName = taskName_example # String | Name of the task

try: 
    # Get a task's end date.
    api_response = api_instance.get_task_end_date(simid, workflowName, taskName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskEndDate: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
workflow_name*
String
Required
task_name*
String
Name of the task
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskEndDate_1

Get an action's end date.


/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetEndDate

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetEndDate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TimeResponse result = apiInstance.getTaskEndDate_0(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskEndDate_0");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TimeResponse result = apiInstance.getTaskEndDate_0(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskEndDate_0");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's end date.
[apiInstance getTaskEndDate_1With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TimeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskEndDate_0(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskEndDate_0Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's end date.
                TimeResponse result = apiInstance.getTaskEndDate_0(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskEndDate_0: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskEndDate_0($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskEndDate_0: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskEndDate_0(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskEndDate_0: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's end date.
    api_response = api_instance.get_task_end_date_0(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskEndDate_0: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops

Get a task's flops


/simulation/{simid}/workflows/{workflow_name}/tasks/{task_name}/taskGetFlops

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/workflows/{workflow_name}/tasks/{task_name}/taskGetFlops"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | Name of the workflow
        String taskName = taskName_example; // String | Name of the task
        try {
            TaskFlops result = apiInstance.getTaskFlops(simid, workflowName, taskName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | Name of the workflow
        String taskName = taskName_example; // String | Name of the task
        try {
            TaskFlops result = apiInstance.getTaskFlops(simid, workflowName, taskName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *workflowName = workflowName_example; // Name of the workflow
String *taskName = taskName_example; // Name of the task

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get a task's flops
[apiInstance getTaskFlopsWith:simid
    workflowName:workflowName
    taskName:taskName
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var workflowName = workflowName_example; // {{String}} Name of the workflow
var taskName = taskName_example; // {{String}} Name of the task

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops(simid, workflowName, taskName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlopsExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var workflowName = workflowName_example;  // String | Name of the workflow
            var taskName = taskName_example;  // String | Name of the task

            try
            {
                // Get a task's flops
                TaskFlops result = apiInstance.getTaskFlops(simid, workflowName, taskName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$workflowName = workflowName_example; // String | Name of the workflow
$taskName = taskName_example; // String | Name of the task

try {
    $result = $api_instance->getTaskFlops($simid, $workflowName, $taskName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $workflowName = workflowName_example; # String | Name of the workflow
my $taskName = taskName_example; # String | Name of the task

eval { 
    my $result = $api_instance->getTaskFlops(simid => $simid, workflowName => $workflowName, taskName => $taskName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
workflowName = workflowName_example # String | Name of the workflow
taskName = taskName_example # String | Name of the task

try: 
    # Get a task's flops
    api_response = api_instance.get_task_flops(simid, workflowName, taskName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
workflow_name*
String
Name of the workflow
Required
task_name*
String
Name of the task
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_2

Get an action's flops


/simulation/{simid}/compoundJobs/{compound_job_name}/setPriority

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/setPriority"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_0(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_0");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_0(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_0");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_2With:simid
    compoundJobName:compoundJobName
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_0(simid, compoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_0Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_0(simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_0: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->getTaskFlops_0($simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_0: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->getTaskFlops_0(simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_0: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_0(simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_0: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_3

Get an action's flops


/simulation/{simid}/compoundJobs/{compound_job_name}/getParentJobs

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/getParentJobs"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_1(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_1");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_1(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_1");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_3With:simid
    compoundJobName:compoundJobName
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_1(simid, compoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_1Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_1(simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_1: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->getTaskFlops_1($simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_1: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->getTaskFlops_1(simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_1: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_1(simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_1: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_4

Get an action's flops


/simulation/{simid}/compoundJobs/{compound_job_name}/addFileRegistryAddEntryAction

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/addFileRegistryAddEntryAction"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_10(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_10");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_10(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_10");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_4With:simid
    compoundJobName:compoundJobName
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_10(simid, compoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_10Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_10(simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_10: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->getTaskFlops_10($simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_10: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->getTaskFlops_10(simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_10: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_10(simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_10: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_5

Get an action's flops


/simulation/{simid}/compoundJobs/{compound_job_name}/addFileRegistryDeleteEntryAction

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/addFileRegistryDeleteEntryAction"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_11(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_11");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_11(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_11");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_5With:simid
    compoundJobName:compoundJobName
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_11(simid, compoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_11Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_11(simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_11: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->getTaskFlops_11($simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_11: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->getTaskFlops_11(simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_11: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_11(simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_11: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_6

Get an action's flops


/simulation/{simid}/compoundJobs/{compound_job_name}/removeAction

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/removeAction"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_12(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_12");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_12(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_12");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_6With:simid
    compoundJobName:compoundJobName
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_12(simid, compoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_12Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_12(simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_12: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->getTaskFlops_12($simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_12: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->getTaskFlops_12(simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_12: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_12(simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_12: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_7

Get an action's flops


/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetParents

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetParents"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_13(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_13");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_13(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_13");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_7With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_13(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_13Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_13(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_13: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskFlops_13($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_13: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskFlops_13(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_13: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_13(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_13: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_8

Get an action's flops


/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetChildren

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetChildren"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_14(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_14");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_14(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_14");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_8With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_14(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_14Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_14(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_14: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskFlops_14($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_14: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskFlops_14(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_14: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_14(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_14: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_9

Get an action's flops


/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetPriority

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetPriority"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_15(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_15");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_15(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_15");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_9With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_15(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_15Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_15(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_15: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskFlops_15($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_15: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskFlops_15(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_15: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_15(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_15: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_10

Get an action's flops


/simulation/{simid}/{compound_job_name}/actions/{name}/actionSetPriority

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/actionSetPriority"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_16(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_16");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_16(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_16");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_10With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_16(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_16Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_16(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_16: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskFlops_16($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_16: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskFlops_16(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_16: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_16(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_16: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_11

Get an action's flops


/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetFlops

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetFlops"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_17(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_17");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_17(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_17");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_11With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_17(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_17Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_17(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_17: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskFlops_17($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_17: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskFlops_17(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_17: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_17(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_17: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_12

Get an action's flops


/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetState

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetState"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_18(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_18");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_18(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_18");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_12With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_18(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_18Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_18(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_18: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskFlops_18($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_18: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskFlops_18(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_18: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_18(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_18: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_13

Get an action's flops


/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetExecutionHistory

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetExecutionHistory"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_19(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_19");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_19(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_19");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_13With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_19(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_19Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_19(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_19: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskFlops_19($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_19: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskFlops_19(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_19: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_19(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_19: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_14

Get an action's flops


/simulation/{simid}/compoundJobs/{compound_job_name}/addChildJob

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/addChildJob"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_2(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_2");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_2(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_2");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_14With:simid
    compoundJobName:compoundJobName
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_2(simid, compoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_2Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_2(simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_2: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->getTaskFlops_2($simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_2: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->getTaskFlops_2(simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_2: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_2(simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_2: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_15

Get an action's flops


/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetFailureCause

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetFailureCause"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_20(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_20");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_20(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_20");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_15With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_20(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_20Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_20(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_20: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskFlops_20($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_20: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskFlops_20(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_20: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_20(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_20: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_16

Get an action's flops


/simulation/{simid}/{compound_job_name}/actions/{name}/fileCopyAction/getDestinationFileLocation

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/fileCopyAction/getDestinationFileLocation"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_21(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_21");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_21(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_21");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_16With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_21(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_21Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_21(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_21: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskFlops_21($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_21: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskFlops_21(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_21: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_21(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_21: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_17

Get an action's flops


/simulation/{simid}/{compound_job_name}/actions/{name}/fileCopyAction/getFile

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/fileCopyAction/getFile"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_22(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_22");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_22(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_22");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_17With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_22(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_22Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_22(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_22: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskFlops_22($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_22: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskFlops_22(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_22: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_22(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_22: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_18

Get an action's flops


/simulation/{simid}/{compound_job_name}/actions/{name}/fileCopyAction/getSourceFileLocation

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/fileCopyAction/getSourceFileLocation"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_23(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_23");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_23(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_23");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_18With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_23(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_23Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_23(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_23: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskFlops_23($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_23: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskFlops_23(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_23: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_23(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_23: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_19

Get an action's flops


/simulation/{simid}/{compound_job_name}/actions/{name}/fileReadAction/getUsedFileLocation

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/fileReadAction/getUsedFileLocation"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_24(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_24");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_24(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_24");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_19With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_24(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_24Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_24(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_24: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskFlops_24($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_24: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskFlops_24(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_24: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_24(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_24: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_20

Get an action's flops


/simulation/{simid}/{compound_job_name}/actions/{name}/fileRegistryAction/getFile

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/fileRegistryAction/getFile"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_25(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_25");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_25(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_25");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_20With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_25(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_25Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_25(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_25: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskFlops_25($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_25: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskFlops_25(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_25: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_25(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_25: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_21

Get an action's flops


/simulation/{simid}/{compound_job_name}/actions/{name}/fileRegistryAction/getFileLocation

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/fileRegistryAction/getFileLocation"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_26(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_26");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_26(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_26");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_21With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_26(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_26Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_26(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_26: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskFlops_26($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_26: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskFlops_26(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_26: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_26(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_26: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_22

Get an action's flops


/simulation/{simid}/{compound_job_name}/actions/{name}/fileRegistryAction/getFileRegistryService

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/fileRegistryAction/getFileRegistryService"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_27(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_27");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskFlops result = apiInstance.getTaskFlops_27(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_27");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_22With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_27(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_27Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_27(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_27: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskFlops_27($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_27: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskFlops_27(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_27: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_27(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_27: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_23

Get an action's flops


/simulation/{simid}/compoundJobs/{compound_job_name}/getChildrenJobs

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/getChildrenJobs"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_3(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_3");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_3(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_3");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_23With:simid
    compoundJobName:compoundJobName
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_3(simid, compoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_3Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_3(simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_3: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->getTaskFlops_3($simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_3: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->getTaskFlops_3(simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_3: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_3(simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_3: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_24

Get an action's flops


/simulation/{simid}/compoundJobs/{compound_job_name}/getMinimumRequiredMemory

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/getMinimumRequiredMemory"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_4(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_4");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_4(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_4");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_24With:simid
    compoundJobName:compoundJobName
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_4(simid, compoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_4Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_4(simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_4: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->getTaskFlops_4($simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_4: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->getTaskFlops_4(simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_4: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_4(simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_4: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_25

Get an action's flops


/simulation/{simid}/compoundJobs/{compound_job_name}/getMinimumRequiredNumCores

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/getMinimumRequiredNumCores"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_5(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_5");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_5(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_5");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_25With:simid
    compoundJobName:compoundJobName
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_5(simid, compoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_5Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_5(simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_5: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->getTaskFlops_5($simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_5: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->getTaskFlops_5(simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_5: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_5(simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_5: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_26

Get an action's flops


/simulation/{simid}/compoundJobs/{compound_job_name}/getState

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/getState"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_6(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_6");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_6(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_6");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_26With:simid
    compoundJobName:compoundJobName
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_6(simid, compoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_6Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_6(simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_6: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->getTaskFlops_6($simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_6: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->getTaskFlops_6(simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_6: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_6(simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_6: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_27

Get an action's flops


/simulation/{simid}/compoundJobs/{compound_job_name}/hasFailed

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/hasFailed"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_7(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_7");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_7(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_7");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_27With:simid
    compoundJobName:compoundJobName
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_7(simid, compoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_7Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_7(simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_7: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->getTaskFlops_7($simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_7: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->getTaskFlops_7(simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_7: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_7(simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_7: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_28

Get an action's flops


/simulation/{simid}/compoundJobs/{compound_job_name}/hasSuccessfullyCompleted

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/hasSuccessfullyCompleted"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_8(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_8");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_8(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_8");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_28With:simid
    compoundJobName:compoundJobName
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_8(simid, compoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_8Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_8(simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_8: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->getTaskFlops_8($simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_8: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->getTaskFlops_8(simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_8: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_8(simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_8: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskFlops_29

Get an action's flops


/simulation/{simid}/compoundJobs/{compound_job_name}/addActionDependency

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/addActionDependency"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_9(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_9");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            TaskFlops result = apiInstance.getTaskFlops_9(simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskFlops_9");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's flops
[apiInstance getTaskFlops_29With:simid
    compoundJobName:compoundJobName
              completionHandler: ^(TaskFlops output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskFlops_9(simid, compoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskFlops_9Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Get an action's flops
                TaskFlops result = apiInstance.getTaskFlops_9(simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskFlops_9: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->getTaskFlops_9($simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskFlops_9: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->getTaskFlops_9(simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskFlops_9: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Get an action's flops
    api_response = api_instance.get_task_flops_9(simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskFlops_9: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskInputFiles

Retrieve task's input files


/simulation/{simid}/workflows/{workflow_name}/tasks/{tid}/inputFiles

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/workflows/{workflow_name}/tasks/{tid}/inputFiles"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        String tid = tid_example; // String | ID of the task
        try {
            FileList result = apiInstance.getTaskInputFiles(simid, workflowName, tid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskInputFiles");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        String tid = tid_example; // String | ID of the task
        try {
            FileList result = apiInstance.getTaskInputFiles(simid, workflowName, tid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskInputFiles");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *workflowName = workflowName_example; // 
String *tid = tid_example; // ID of the task

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Retrieve task's input files
[apiInstance getTaskInputFilesWith:simid
    workflowName:workflowName
    tid:tid
              completionHandler: ^(FileList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var workflowName = workflowName_example; // {{String}} 
var tid = tid_example; // {{String}} ID of the task

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskInputFiles(simid, workflowName, tid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskInputFilesExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var workflowName = workflowName_example;  // String | 
            var tid = tid_example;  // String | ID of the task

            try
            {
                // Retrieve task's input files
                FileList result = apiInstance.getTaskInputFiles(simid, workflowName, tid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskInputFiles: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$workflowName = workflowName_example; // String | 
$tid = tid_example; // String | ID of the task

try {
    $result = $api_instance->getTaskInputFiles($simid, $workflowName, $tid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskInputFiles: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $workflowName = workflowName_example; # String | 
my $tid = tid_example; # String | ID of the task

eval { 
    my $result = $api_instance->getTaskInputFiles(simid => $simid, workflowName => $workflowName, tid => $tid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskInputFiles: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
workflowName = workflowName_example # String | 
tid = tid_example # String | ID of the task

try: 
    # Retrieve task's input files
    api_response = api_instance.get_task_input_files(simid, workflowName, tid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskInputFiles: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
workflow_name*
String
Required
tid*
String
ID of the task
Required

Responses

Status: 200 - OK

Status: 404 - Task not found

Status: 405 - Invalid input


getTaskMaxNumCores

Get a task's maximum number of cores.


/simulation/{simid}/workflows/{workflow_name}/tasks/{task_name}/taskGetMaxNumCores

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/workflows/{workflow_name}/tasks/{task_name}/taskGetMaxNumCores"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        String taskName = taskName_example; // String | Name of the task
        try {
            TaskCores result = apiInstance.getTaskMaxNumCores(simid, workflowName, taskName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMaxNumCores");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        String taskName = taskName_example; // String | Name of the task
        try {
            TaskCores result = apiInstance.getTaskMaxNumCores(simid, workflowName, taskName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMaxNumCores");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *workflowName = workflowName_example; // 
String *taskName = taskName_example; // Name of the task

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get a task's maximum number of cores.
[apiInstance getTaskMaxNumCoresWith:simid
    workflowName:workflowName
    taskName:taskName
              completionHandler: ^(TaskCores output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var workflowName = workflowName_example; // {{String}} 
var taskName = taskName_example; // {{String}} Name of the task

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskMaxNumCores(simid, workflowName, taskName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskMaxNumCoresExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var workflowName = workflowName_example;  // String | 
            var taskName = taskName_example;  // String | Name of the task

            try
            {
                // Get a task's maximum number of cores.
                TaskCores result = apiInstance.getTaskMaxNumCores(simid, workflowName, taskName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskMaxNumCores: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$workflowName = workflowName_example; // String | 
$taskName = taskName_example; // String | Name of the task

try {
    $result = $api_instance->getTaskMaxNumCores($simid, $workflowName, $taskName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskMaxNumCores: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $workflowName = workflowName_example; # String | 
my $taskName = taskName_example; # String | Name of the task

eval { 
    my $result = $api_instance->getTaskMaxNumCores(simid => $simid, workflowName => $workflowName, taskName => $taskName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskMaxNumCores: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
workflowName = workflowName_example # String | 
taskName = taskName_example # String | Name of the task

try: 
    # Get a task's maximum number of cores.
    api_response = api_instance.get_task_max_num_cores(simid, workflowName, taskName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskMaxNumCores: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
workflow_name*
String
Required
task_name*
String
Name of the task
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskMaxNumCores_30

Get an action's maximum number of cores.


/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetMaxNumCores

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetMaxNumCores"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskCores result = apiInstance.getTaskMaxNumCores_0(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMaxNumCores_0");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskCores result = apiInstance.getTaskMaxNumCores_0(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMaxNumCores_0");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's maximum number of cores.
[apiInstance getTaskMaxNumCores_30With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TaskCores output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskMaxNumCores_0(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskMaxNumCores_0Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's maximum number of cores.
                TaskCores result = apiInstance.getTaskMaxNumCores_0(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskMaxNumCores_0: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskMaxNumCores_0($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskMaxNumCores_0: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskMaxNumCores_0(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskMaxNumCores_0: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's maximum number of cores.
    api_response = api_instance.get_task_max_num_cores_0(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskMaxNumCores_0: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskMemory

Get a task's memory requirement.


/simulation/{simid}/workflows/{workflow_name}/tasks/{task_name}/taskGetMemory

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/workflows/{workflow_name}/tasks/{task_name}/taskGetMemory"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        String taskName = taskName_example; // String | Name of the task
        try {
            TaskMem result = apiInstance.getTaskMemory(simid, workflowName, taskName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMemory");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        String taskName = taskName_example; // String | Name of the task
        try {
            TaskMem result = apiInstance.getTaskMemory(simid, workflowName, taskName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMemory");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *workflowName = workflowName_example; // 
String *taskName = taskName_example; // Name of the task

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get a task's memory requirement.
[apiInstance getTaskMemoryWith:simid
    workflowName:workflowName
    taskName:taskName
              completionHandler: ^(TaskMem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var workflowName = workflowName_example; // {{String}} 
var taskName = taskName_example; // {{String}} Name of the task

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskMemory(simid, workflowName, taskName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskMemoryExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var workflowName = workflowName_example;  // String | 
            var taskName = taskName_example;  // String | Name of the task

            try
            {
                // Get a task's memory requirement.
                TaskMem result = apiInstance.getTaskMemory(simid, workflowName, taskName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskMemory: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$workflowName = workflowName_example; // String | 
$taskName = taskName_example; // String | Name of the task

try {
    $result = $api_instance->getTaskMemory($simid, $workflowName, $taskName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskMemory: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $workflowName = workflowName_example; # String | 
my $taskName = taskName_example; # String | Name of the task

eval { 
    my $result = $api_instance->getTaskMemory(simid => $simid, workflowName => $workflowName, taskName => $taskName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskMemory: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
workflowName = workflowName_example # String | 
taskName = taskName_example # String | Name of the task

try: 
    # Get a task's memory requirement.
    api_response = api_instance.get_task_memory(simid, workflowName, taskName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskMemory: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
workflow_name*
String
Required
task_name*
String
Name of the task
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskMemory_31

Get an action's memory requirement.


/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetMemory

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetMemory"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskMem result = apiInstance.getTaskMemory_0(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMemory_0");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskMem result = apiInstance.getTaskMemory_0(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMemory_0");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's memory requirement.
[apiInstance getTaskMemory_31With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TaskMem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskMemory_0(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskMemory_0Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's memory requirement.
                TaskMem result = apiInstance.getTaskMemory_0(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskMemory_0: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskMemory_0($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskMemory_0: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskMemory_0(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskMemory_0: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's memory requirement.
    api_response = api_instance.get_task_memory_0(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskMemory_0: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskMemory_32

Get an action's memory requirement.


/simulation/{simid}/{compound_job_name}/actions/{name}/actionUsesScratch

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/actionUsesScratch"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskMem result = apiInstance.getTaskMemory_1(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMemory_1");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskMem result = apiInstance.getTaskMemory_1(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMemory_1");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's memory requirement.
[apiInstance getTaskMemory_32With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TaskMem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskMemory_1(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskMemory_1Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's memory requirement.
                TaskMem result = apiInstance.getTaskMemory_1(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskMemory_1: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskMemory_1($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskMemory_1: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskMemory_1(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskMemory_1: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's memory requirement.
    api_response = api_instance.get_task_memory_1(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskMemory_1: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskMinNumCores

Get a task's minimum number of cores.


/simulation/{simid}/workflows/{workflow_name}/tasks/{task_name}/taskGetMinNumCores

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/workflows/{workflow_name}/tasks/{task_name}/taskGetMinNumCores"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        String taskName = taskName_example; // String | Name of the task
        try {
            TaskCores result = apiInstance.getTaskMinNumCores(simid, workflowName, taskName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMinNumCores");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        String taskName = taskName_example; // String | Name of the task
        try {
            TaskCores result = apiInstance.getTaskMinNumCores(simid, workflowName, taskName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMinNumCores");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *workflowName = workflowName_example; // 
String *taskName = taskName_example; // Name of the task

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get a task's minimum number of cores.
[apiInstance getTaskMinNumCoresWith:simid
    workflowName:workflowName
    taskName:taskName
              completionHandler: ^(TaskCores output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var workflowName = workflowName_example; // {{String}} 
var taskName = taskName_example; // {{String}} Name of the task

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskMinNumCores(simid, workflowName, taskName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskMinNumCoresExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var workflowName = workflowName_example;  // String | 
            var taskName = taskName_example;  // String | Name of the task

            try
            {
                // Get a task's minimum number of cores.
                TaskCores result = apiInstance.getTaskMinNumCores(simid, workflowName, taskName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskMinNumCores: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$workflowName = workflowName_example; // String | 
$taskName = taskName_example; // String | Name of the task

try {
    $result = $api_instance->getTaskMinNumCores($simid, $workflowName, $taskName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskMinNumCores: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $workflowName = workflowName_example; # String | 
my $taskName = taskName_example; # String | Name of the task

eval { 
    my $result = $api_instance->getTaskMinNumCores(simid => $simid, workflowName => $workflowName, taskName => $taskName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskMinNumCores: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
workflowName = workflowName_example # String | 
taskName = taskName_example # String | Name of the task

try: 
    # Get a task's minimum number of cores.
    api_response = api_instance.get_task_min_num_cores(simid, workflowName, taskName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskMinNumCores: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
workflow_name*
String
Required
task_name*
String
Name of the task
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskMinNumCores_33

Get an action's minimum number of cores.


/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetMinNumCores

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetMinNumCores"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskCores result = apiInstance.getTaskMinNumCores_0(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMinNumCores_0");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskCores result = apiInstance.getTaskMinNumCores_0(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMinNumCores_0");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's minimum number of cores.
[apiInstance getTaskMinNumCores_33With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TaskCores output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskMinNumCores_0(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskMinNumCores_0Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's minimum number of cores.
                TaskCores result = apiInstance.getTaskMinNumCores_0(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskMinNumCores_0: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskMinNumCores_0($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskMinNumCores_0: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskMinNumCores_0(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskMinNumCores_0: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's minimum number of cores.
    api_response = api_instance.get_task_min_num_cores_0(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskMinNumCores_0: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskMinNumCores_34

Get an action's minimum number of cores.


/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetMinRAMFootprint

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetMinRAMFootprint"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskCores result = apiInstance.getTaskMinNumCores_1(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMinNumCores_1");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TaskCores result = apiInstance.getTaskMinNumCores_1(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskMinNumCores_1");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's minimum number of cores.
[apiInstance getTaskMinNumCores_34With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TaskCores output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskMinNumCores_1(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskMinNumCores_1Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's minimum number of cores.
                TaskCores result = apiInstance.getTaskMinNumCores_1(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskMinNumCores_1: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskMinNumCores_1($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskMinNumCores_1: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskMinNumCores_1(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskMinNumCores_1: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's minimum number of cores.
    api_response = api_instance.get_task_min_num_cores_1(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskMinNumCores_1: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskOutputFiles

Retrieve task's output files


/simulation/{simid}/workflows/{workflow_name}/tasks/{tid}/outputFiles

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/workflows/{workflow_name}/tasks/{tid}/outputFiles"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        String tid = tid_example; // String | ID of the task
        try {
            FileList result = apiInstance.getTaskOutputFiles(simid, workflowName, tid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskOutputFiles");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        String tid = tid_example; // String | ID of the task
        try {
            FileList result = apiInstance.getTaskOutputFiles(simid, workflowName, tid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskOutputFiles");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *workflowName = workflowName_example; // 
String *tid = tid_example; // ID of the task

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Retrieve task's output files
[apiInstance getTaskOutputFilesWith:simid
    workflowName:workflowName
    tid:tid
              completionHandler: ^(FileList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var workflowName = workflowName_example; // {{String}} 
var tid = tid_example; // {{String}} ID of the task

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskOutputFiles(simid, workflowName, tid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskOutputFilesExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var workflowName = workflowName_example;  // String | 
            var tid = tid_example;  // String | ID of the task

            try
            {
                // Retrieve task's output files
                FileList result = apiInstance.getTaskOutputFiles(simid, workflowName, tid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskOutputFiles: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$workflowName = workflowName_example; // String | 
$tid = tid_example; // String | ID of the task

try {
    $result = $api_instance->getTaskOutputFiles($simid, $workflowName, $tid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskOutputFiles: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $workflowName = workflowName_example; # String | 
my $tid = tid_example; # String | ID of the task

eval { 
    my $result = $api_instance->getTaskOutputFiles(simid => $simid, workflowName => $workflowName, tid => $tid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskOutputFiles: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
workflowName = workflowName_example # String | 
tid = tid_example # String | ID of the task

try: 
    # Retrieve task's output files
    api_response = api_instance.get_task_output_files(simid, workflowName, tid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskOutputFiles: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
workflow_name*
String
Required
tid*
String
ID of the task
Required

Responses

Status: 200 - OK

Status: 404 - Task not found

Status: 405 - Invalid input


getTaskStartDate

Get a task's start date.


/simulation/{simid}/workflows/{workflow_name}/tasks/{task_name}/taskGetStartDate

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/workflows/{workflow_name}/tasks/{task_name}/taskGetStartDate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        String taskName = taskName_example; // String | Name of the task
        try {
            TimeResponse result = apiInstance.getTaskStartDate(simid, workflowName, taskName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskStartDate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        String taskName = taskName_example; // String | Name of the task
        try {
            TimeResponse result = apiInstance.getTaskStartDate(simid, workflowName, taskName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskStartDate");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *workflowName = workflowName_example; // 
String *taskName = taskName_example; // Name of the task

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get a task's start date.
[apiInstance getTaskStartDateWith:simid
    workflowName:workflowName
    taskName:taskName
              completionHandler: ^(TimeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var workflowName = workflowName_example; // {{String}} 
var taskName = taskName_example; // {{String}} Name of the task

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskStartDate(simid, workflowName, taskName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskStartDateExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var workflowName = workflowName_example;  // String | 
            var taskName = taskName_example;  // String | Name of the task

            try
            {
                // Get a task's start date.
                TimeResponse result = apiInstance.getTaskStartDate(simid, workflowName, taskName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskStartDate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$workflowName = workflowName_example; // String | 
$taskName = taskName_example; // String | Name of the task

try {
    $result = $api_instance->getTaskStartDate($simid, $workflowName, $taskName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskStartDate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $workflowName = workflowName_example; # String | 
my $taskName = taskName_example; # String | Name of the task

eval { 
    my $result = $api_instance->getTaskStartDate(simid => $simid, workflowName => $workflowName, taskName => $taskName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskStartDate: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
workflowName = workflowName_example # String | 
taskName = taskName_example # String | Name of the task

try: 
    # Get a task's start date.
    api_response = api_instance.get_task_start_date(simid, workflowName, taskName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskStartDate: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
workflow_name*
String
Required
task_name*
String
Name of the task
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getTaskStartDate_35

Get an action's start date.


/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetStartDate

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/{compound_job_name}/actions/{name}/actionGetStartDate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TimeResponse result = apiInstance.getTaskStartDate_0(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskStartDate_0");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        String name = name_example; // String | Name of the action
        try {
            TimeResponse result = apiInstance.getTaskStartDate_0(simid, compoundJobName, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getTaskStartDate_0");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job
String *name = name_example; // Name of the action

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get an action's start date.
[apiInstance getTaskStartDate_35With:simid
    compoundJobName:compoundJobName
    name:name
              completionHandler: ^(TimeResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job
var name = name_example; // {{String}} Name of the action

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTaskStartDate_0(simid, compoundJobName, name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTaskStartDate_0Example
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job
            var name = name_example;  // String | Name of the action

            try
            {
                // Get an action's start date.
                TimeResponse result = apiInstance.getTaskStartDate_0(simid, compoundJobName, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getTaskStartDate_0: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job
$name = name_example; // String | Name of the action

try {
    $result = $api_instance->getTaskStartDate_0($simid, $compoundJobName, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getTaskStartDate_0: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job
my $name = name_example; # String | Name of the action

eval { 
    my $result = $api_instance->getTaskStartDate_0(simid => $simid, compoundJobName => $compoundJobName, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getTaskStartDate_0: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job
name = name_example # String | Name of the action

try: 
    # Get an action's start date.
    api_response = api_instance.get_task_start_date_0(simid, compoundJobName, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getTaskStartDate_0: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
name*
String
Name of the action
Required

Responses

Status: 200 - OK

Status: 404 - Job not found

Status: 405 - Invalid input


getVMComputeService

Get the compute service running on a VM, if any.


/simulation/{simid}/cloud_compute_services/{service_name}/vms/{vm_name}/getVMComputeService

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/cloud_compute_services/{service_name}/vms/{vm_name}/getVMComputeService"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The cloud compute service name
        String vmName = vmName_example; // String | The VM name
        try {
            ServiceResponse result = apiInstance.getVMComputeService(simid, serviceName, vmName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getVMComputeService");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The cloud compute service name
        String vmName = vmName_example; // String | The VM name
        try {
            ServiceResponse result = apiInstance.getVMComputeService(simid, serviceName, vmName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getVMComputeService");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *serviceName = serviceName_example; // The cloud compute service name
String *vmName = vmName_example; // The VM name

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get the compute service running on a VM, if any.
[apiInstance getVMComputeServiceWith:simid
    serviceName:serviceName
    vmName:vmName
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var serviceName = serviceName_example; // {{String}} The cloud compute service name
var vmName = vmName_example; // {{String}} The VM name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getVMComputeService(simid, serviceName, vmName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getVMComputeServiceExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var serviceName = serviceName_example;  // String | The cloud compute service name
            var vmName = vmName_example;  // String | The VM name

            try
            {
                // Get the compute service running on a VM, if any.
                ServiceResponse result = apiInstance.getVMComputeService(simid, serviceName, vmName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getVMComputeService: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$serviceName = serviceName_example; // String | The cloud compute service name
$vmName = vmName_example; // String | The VM name

try {
    $result = $api_instance->getVMComputeService($simid, $serviceName, $vmName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getVMComputeService: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $serviceName = serviceName_example; # String | The cloud compute service name
my $vmName = vmName_example; # String | The VM name

eval { 
    my $result = $api_instance->getVMComputeService(simid => $simid, serviceName => $serviceName, vmName => $vmName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getVMComputeService: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
serviceName = serviceName_example # String | The cloud compute service name
vmName = vmName_example # String | The VM name

try: 
    # Get the compute service running on a VM, if any.
    api_response = api_instance.get_vm_compute_service(simid, serviceName, vmName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getVMComputeService: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
service_name*
String
The cloud compute service name
Required
vm_name*
String
The VM name
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


getVMPhysicalHostname

Get the name of the physical host on which a VM is running.


/simulation/{simid}/cloud_compute_services/{service_name}/vms/{vm_name}/getVMPhysicalHostname

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/cloud_compute_services/{service_name}/vms/{vm_name}/getVMPhysicalHostname"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The cloud compute service name
        String vmName = vmName_example; // String | The VM name
        try {
            ServiceResponse result = apiInstance.getVMPhysicalHostname(simid, serviceName, vmName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getVMPhysicalHostname");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The cloud compute service name
        String vmName = vmName_example; // String | The VM name
        try {
            ServiceResponse result = apiInstance.getVMPhysicalHostname(simid, serviceName, vmName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#getVMPhysicalHostname");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *serviceName = serviceName_example; // The cloud compute service name
String *vmName = vmName_example; // The VM name

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Get the name of the physical host on which a VM is running.
[apiInstance getVMPhysicalHostnameWith:simid
    serviceName:serviceName
    vmName:vmName
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var serviceName = serviceName_example; // {{String}} The cloud compute service name
var vmName = vmName_example; // {{String}} The VM name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getVMPhysicalHostname(simid, serviceName, vmName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getVMPhysicalHostnameExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var serviceName = serviceName_example;  // String | The cloud compute service name
            var vmName = vmName_example;  // String | The VM name

            try
            {
                // Get the name of the physical host on which a VM is running.
                ServiceResponse result = apiInstance.getVMPhysicalHostname(simid, serviceName, vmName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.getVMPhysicalHostname: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$serviceName = serviceName_example; // String | The cloud compute service name
$vmName = vmName_example; // String | The VM name

try {
    $result = $api_instance->getVMPhysicalHostname($simid, $serviceName, $vmName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->getVMPhysicalHostname: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $serviceName = serviceName_example; # String | The cloud compute service name
my $vmName = vmName_example; # String | The VM name

eval { 
    my $result = $api_instance->getVMPhysicalHostname(simid => $simid, serviceName => $serviceName, vmName => $vmName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->getVMPhysicalHostname: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
serviceName = serviceName_example # String | The cloud compute service name
vmName = vmName_example # String | The VM name

try: 
    # Get the name of the physical host on which a VM is running.
    api_response = api_instance.get_vm_physical_hostname(simid, serviceName, vmName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->getVMPhysicalHostname: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
service_name*
String
The cloud compute service name
Required
vm_name*
String
The VM name
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


isVMDown

Method to check whether a VM is currently down.


/simulation/{simid}/cloud_compute_services/{service_name}/vms/{vm_name}/isVMDown

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/cloud_compute_services/{service_name}/vms/{vm_name}/isVMDown"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The cloud compute service name
        String vmName = vmName_example; // String | The VM name
        try {
            ServiceResponse result = apiInstance.isVMDown(simid, serviceName, vmName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#isVMDown");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The cloud compute service name
        String vmName = vmName_example; // String | The VM name
        try {
            ServiceResponse result = apiInstance.isVMDown(simid, serviceName, vmName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#isVMDown");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *serviceName = serviceName_example; // The cloud compute service name
String *vmName = vmName_example; // The VM name

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Method to check whether a VM is currently down.
[apiInstance isVMDownWith:simid
    serviceName:serviceName
    vmName:vmName
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var serviceName = serviceName_example; // {{String}} The cloud compute service name
var vmName = vmName_example; // {{String}} The VM name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.isVMDown(simid, serviceName, vmName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class isVMDownExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var serviceName = serviceName_example;  // String | The cloud compute service name
            var vmName = vmName_example;  // String | The VM name

            try
            {
                // Method to check whether a VM is currently down.
                ServiceResponse result = apiInstance.isVMDown(simid, serviceName, vmName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.isVMDown: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$serviceName = serviceName_example; // String | The cloud compute service name
$vmName = vmName_example; // String | The VM name

try {
    $result = $api_instance->isVMDown($simid, $serviceName, $vmName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->isVMDown: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $serviceName = serviceName_example; # String | The cloud compute service name
my $vmName = vmName_example; # String | The VM name

eval { 
    my $result = $api_instance->isVMDown(simid => $simid, serviceName => $serviceName, vmName => $vmName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->isVMDown: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
serviceName = serviceName_example # String | The cloud compute service name
vmName = vmName_example # String | The VM name

try: 
    # Method to check whether a VM is currently down.
    api_response = api_instance.is_vm_down(simid, serviceName, vmName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->isVMDown: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
service_name*
String
The cloud compute service name
Required
vm_name*
String
The VM name
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


isVMRunning

Method to check whether a VM is currently running.


/simulation/{simid}/cloud_compute_services/{service_name}/vms/{vm_name}/isVMRunning

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/cloud_compute_services/{service_name}/vms/{vm_name}/isVMRunning"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | Name of the cloud compute service
        String vmName = vmName_example; // String | Name of the vm
        try {
            ServiceResponse result = apiInstance.isVMRunning(simid, serviceName, vmName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#isVMRunning");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | Name of the cloud compute service
        String vmName = vmName_example; // String | Name of the vm
        try {
            ServiceResponse result = apiInstance.isVMRunning(simid, serviceName, vmName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#isVMRunning");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *serviceName = serviceName_example; // Name of the cloud compute service
String *vmName = vmName_example; // Name of the vm

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Method to check whether a VM is currently running.
[apiInstance isVMRunningWith:simid
    serviceName:serviceName
    vmName:vmName
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var serviceName = serviceName_example; // {{String}} Name of the cloud compute service
var vmName = vmName_example; // {{String}} Name of the vm

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.isVMRunning(simid, serviceName, vmName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class isVMRunningExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var serviceName = serviceName_example;  // String | Name of the cloud compute service
            var vmName = vmName_example;  // String | Name of the vm

            try
            {
                // Method to check whether a VM is currently running.
                ServiceResponse result = apiInstance.isVMRunning(simid, serviceName, vmName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.isVMRunning: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$serviceName = serviceName_example; // String | Name of the cloud compute service
$vmName = vmName_example; // String | Name of the vm

try {
    $result = $api_instance->isVMRunning($simid, $serviceName, $vmName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->isVMRunning: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $serviceName = serviceName_example; # String | Name of the cloud compute service
my $vmName = vmName_example; # String | Name of the vm

eval { 
    my $result = $api_instance->isVMRunning(simid => $simid, serviceName => $serviceName, vmName => $vmName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->isVMRunning: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
serviceName = serviceName_example # String | Name of the cloud compute service
vmName = vmName_example # String | Name of the vm

try: 
    # Method to check whether a VM is currently running.
    api_response = api_instance.is_vm_running(simid, serviceName, vmName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->isVMRunning: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
service_name*
String
Name of the cloud compute service
Required
vm_name*
String
Name of the vm
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


isVMSuspended

Method to check whether a VM is currently suspended.


/simulation/{simid}/cloud_compute_services/{service_name}/vms/{vm_name}/isVMSuspended

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/cloud_compute_services/{service_name}/vms/{vm_name}/isVMSuspended"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The cloud compute service name
        String vmName = vmName_example; // String | The VM name
        try {
            ServiceResponse result = apiInstance.isVMSuspended(simid, serviceName, vmName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#isVMSuspended");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The cloud compute service name
        String vmName = vmName_example; // String | The VM name
        try {
            ServiceResponse result = apiInstance.isVMSuspended(simid, serviceName, vmName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#isVMSuspended");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *serviceName = serviceName_example; // The cloud compute service name
String *vmName = vmName_example; // The VM name

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Method to check whether a VM is currently suspended.
[apiInstance isVMSuspendedWith:simid
    serviceName:serviceName
    vmName:vmName
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var serviceName = serviceName_example; // {{String}} The cloud compute service name
var vmName = vmName_example; // {{String}} The VM name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.isVMSuspended(simid, serviceName, vmName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class isVMSuspendedExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var serviceName = serviceName_example;  // String | The cloud compute service name
            var vmName = vmName_example;  // String | The VM name

            try
            {
                // Method to check whether a VM is currently suspended.
                ServiceResponse result = apiInstance.isVMSuspended(simid, serviceName, vmName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.isVMSuspended: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$serviceName = serviceName_example; // String | The cloud compute service name
$vmName = vmName_example; // String | The VM name

try {
    $result = $api_instance->isVMSuspended($simid, $serviceName, $vmName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->isVMSuspended: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $serviceName = serviceName_example; # String | The cloud compute service name
my $vmName = vmName_example; # String | The VM name

eval { 
    my $result = $api_instance->isVMSuspended(simid => $simid, serviceName => $serviceName, vmName => $vmName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->isVMSuspended: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
serviceName = serviceName_example # String | The cloud compute service name
vmName = vmName_example # String | The VM name

try: 
    # Method to check whether a VM is currently suspended.
    api_response = api_instance.is_vm_suspended(simid, serviceName, vmName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->isVMSuspended: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
service_name*
String
The cloud compute service name
Required
vm_name*
String
The VM name
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


lookupFileAtStorageService

Check if a copy of a file is stored at a storage service.


/simulation/{simid}/storage_services/{service_name}/lookupFile

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/storage_services/{service_name}/lookupFile"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Service_name_lookupFile_body body = ; // Service_name_lookupFile_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The storage service's head host
        try {
            BooleanResponse result = apiInstance.lookupFileAtStorageService(body, simid, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#lookupFileAtStorageService");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Service_name_lookupFile_body body = ; // Service_name_lookupFile_body | Input to start a new service.
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The storage service's head host
        try {
            BooleanResponse result = apiInstance.lookupFileAtStorageService(body, simid, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#lookupFileAtStorageService");
            e.printStackTrace();
        }
    }
}
Service_name_lookupFile_body *body = ; // Input to start a new service.
String *simid = simid_example; // ID of the simulation
String *serviceName = serviceName_example; // The storage service's head host

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Check if a copy of a file is stored at a storage service.
[apiInstance lookupFileAtStorageServiceWith:body
    simid:simid
    serviceName:serviceName
              completionHandler: ^(BooleanResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Service_name_lookupFile_body}} Input to start a new service.
var simid = simid_example; // {{String}} ID of the simulation
var serviceName = serviceName_example; // {{String}} The storage service's head host

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.lookupFileAtStorageService(bodysimidserviceName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class lookupFileAtStorageServiceExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Service_name_lookupFile_body(); // Service_name_lookupFile_body | Input to start a new service.
            var simid = simid_example;  // String | ID of the simulation
            var serviceName = serviceName_example;  // String | The storage service's head host

            try
            {
                // Check if a copy of a file is stored at a storage service.
                BooleanResponse result = apiInstance.lookupFileAtStorageService(body, simid, serviceName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.lookupFileAtStorageService: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Service_name_lookupFile_body | Input to start a new service.
$simid = simid_example; // String | ID of the simulation
$serviceName = serviceName_example; // String | The storage service's head host

try {
    $result = $api_instance->lookupFileAtStorageService($body, $simid, $serviceName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->lookupFileAtStorageService: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Service_name_lookupFile_body->new(); # Service_name_lookupFile_body | Input to start a new service.
my $simid = simid_example; # String | ID of the simulation
my $serviceName = serviceName_example; # String | The storage service's head host

eval { 
    my $result = $api_instance->lookupFileAtStorageService(body => $body, simid => $simid, serviceName => $serviceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->lookupFileAtStorageService: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Service_name_lookupFile_body | Input to start a new service.
simid = simid_example # String | ID of the simulation
serviceName = serviceName_example # String | The storage service's head host

try: 
    # Check if a copy of a file is stored at a storage service.
    api_response = api_instance.lookup_file_at_storage_service(body, simid, serviceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->lookupFileAtStorageService: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
service_name*
String
The storage service's head host
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 404 - Simulation or storage service not found

Status: 405 - Invalid input


resumeVM

Resume a suspended VM.


/simulation/{simid}/cloud_compute_services/{service_name}/vms/{vm_name}/resumeVM

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/cloud_compute_services/{service_name}/vms/{vm_name}/resumeVM"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The cloud compute service name
        String vmName = vmName_example; // String | The VM name
        try {
            GenericResponse result = apiInstance.resumeVM(simid, serviceName, vmName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#resumeVM");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The cloud compute service name
        String vmName = vmName_example; // String | The VM name
        try {
            GenericResponse result = apiInstance.resumeVM(simid, serviceName, vmName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#resumeVM");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *serviceName = serviceName_example; // The cloud compute service name
String *vmName = vmName_example; // The VM name

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Resume a suspended VM.
[apiInstance resumeVMWith:simid
    serviceName:serviceName
    vmName:vmName
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var serviceName = serviceName_example; // {{String}} The cloud compute service name
var vmName = vmName_example; // {{String}} The VM name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.resumeVM(simid, serviceName, vmName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class resumeVMExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var serviceName = serviceName_example;  // String | The cloud compute service name
            var vmName = vmName_example;  // String | The VM name

            try
            {
                // Resume a suspended VM.
                GenericResponse result = apiInstance.resumeVM(simid, serviceName, vmName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.resumeVM: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$serviceName = serviceName_example; // String | The cloud compute service name
$vmName = vmName_example; // String | The VM name

try {
    $result = $api_instance->resumeVM($simid, $serviceName, $vmName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->resumeVM: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $serviceName = serviceName_example; # String | The cloud compute service name
my $vmName = vmName_example; # String | The VM name

eval { 
    my $result = $api_instance->resumeVM(simid => $simid, serviceName => $serviceName, vmName => $vmName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->resumeVM: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
serviceName = serviceName_example # String | The cloud compute service name
vmName = vmName_example # String | The VM name

try: 
    # Resume a suspended VM.
    api_response = api_instance.resume_vm(simid, serviceName, vmName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->resumeVM: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
service_name*
String
The cloud compute service name
Required
vm_name*
String
The VM name
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


shutdownVM

Shutdown a VM.


/simulation/{simid}/cloud_compute_services/{service_name}/vms/{vm_name}/shutdownVM

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/cloud_compute_services/{service_name}/vms/{vm_name}/shutdownVM"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The cloud compute service name
        String vmName = vmName_example; // String | The VM name
        try {
            ServiceResponse result = apiInstance.shutdownVM(simid, serviceName, vmName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#shutdownVM");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The cloud compute service name
        String vmName = vmName_example; // String | The VM name
        try {
            ServiceResponse result = apiInstance.shutdownVM(simid, serviceName, vmName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#shutdownVM");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *serviceName = serviceName_example; // The cloud compute service name
String *vmName = vmName_example; // The VM name

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Shutdown a VM.
[apiInstance shutdownVMWith:simid
    serviceName:serviceName
    vmName:vmName
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var serviceName = serviceName_example; // {{String}} The cloud compute service name
var vmName = vmName_example; // {{String}} The VM name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.shutdownVM(simid, serviceName, vmName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class shutdownVMExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var serviceName = serviceName_example;  // String | The cloud compute service name
            var vmName = vmName_example;  // String | The VM name

            try
            {
                // Shutdown a VM.
                ServiceResponse result = apiInstance.shutdownVM(simid, serviceName, vmName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.shutdownVM: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$serviceName = serviceName_example; // String | The cloud compute service name
$vmName = vmName_example; // String | The VM name

try {
    $result = $api_instance->shutdownVM($simid, $serviceName, $vmName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->shutdownVM: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $serviceName = serviceName_example; # String | The cloud compute service name
my $vmName = vmName_example; # String | The VM name

eval { 
    my $result = $api_instance->shutdownVM(simid => $simid, serviceName => $serviceName, vmName => $vmName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->shutdownVM: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
serviceName = serviceName_example # String | The cloud compute service name
vmName = vmName_example # String | The VM name

try: 
    # Shutdown a VM.
    api_response = api_instance.shutdown_vm(simid, serviceName, vmName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->shutdownVM: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
service_name*
String
The cloud compute service name
Required
vm_name*
String
The VM name
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


startSimulation

Start a new simulation


/simulation/startSimulation

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/startSimulation"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        SimulationInput body = ; // SimulationInput | Start a new simulation based on a platform file and a controller hostname.
        try {
            SimulationReturn result = apiInstance.startSimulation(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#startSimulation");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        SimulationInput body = ; // SimulationInput | Start a new simulation based on a platform file and a controller hostname.
        try {
            SimulationReturn result = apiInstance.startSimulation(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#startSimulation");
            e.printStackTrace();
        }
    }
}
SimulationInput *body = ; // Start a new simulation based on a platform file and a controller hostname.

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Start a new simulation
[apiInstance startSimulationWith:body
              completionHandler: ^(SimulationReturn output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{SimulationInput}} Start a new simulation based on a platform file and a controller hostname.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.startSimulation(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class startSimulationExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new SimulationInput(); // SimulationInput | Start a new simulation based on a platform file and a controller hostname.

            try
            {
                // Start a new simulation
                SimulationReturn result = apiInstance.startSimulation(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.startSimulation: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // SimulationInput | Start a new simulation based on a platform file and a controller hostname.

try {
    $result = $api_instance->startSimulation($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->startSimulation: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::SimulationInput->new(); # SimulationInput | Start a new simulation based on a platform file and a controller hostname.

eval { 
    my $result = $api_instance->startSimulation(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->startSimulation: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # SimulationInput | Start a new simulation based on a platform file and a controller hostname.

try: 
    # Start a new simulation
    api_response = api_instance.start_simulation(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->startSimulation: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 405 - Invalid input


startVM

Starts a VM and get its associated bare metal compute service.


/simulation/{simid}/cloud_compute_services/{service_name}/vms/{vm_name}/startVM

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/cloud_compute_services/{service_name}/vms/{vm_name}/startVM"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The cloud compute service name
        String vmName = vmName_example; // String | The VM name
        try {
            ServiceResponse result = apiInstance.startVM(simid, serviceName, vmName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#startVM");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The cloud compute service name
        String vmName = vmName_example; // String | The VM name
        try {
            ServiceResponse result = apiInstance.startVM(simid, serviceName, vmName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#startVM");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *serviceName = serviceName_example; // The cloud compute service name
String *vmName = vmName_example; // The VM name

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Starts a VM and get its associated bare metal compute service.
[apiInstance startVMWith:simid
    serviceName:serviceName
    vmName:vmName
              completionHandler: ^(ServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var serviceName = serviceName_example; // {{String}} The cloud compute service name
var vmName = vmName_example; // {{String}} The VM name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.startVM(simid, serviceName, vmName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class startVMExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var serviceName = serviceName_example;  // String | The cloud compute service name
            var vmName = vmName_example;  // String | The VM name

            try
            {
                // Starts a VM and get its associated bare metal compute service.
                ServiceResponse result = apiInstance.startVM(simid, serviceName, vmName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.startVM: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$serviceName = serviceName_example; // String | The cloud compute service name
$vmName = vmName_example; // String | The VM name

try {
    $result = $api_instance->startVM($simid, $serviceName, $vmName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->startVM: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $serviceName = serviceName_example; # String | The cloud compute service name
my $vmName = vmName_example; # String | The VM name

eval { 
    my $result = $api_instance->startVM(simid => $simid, serviceName => $serviceName, vmName => $vmName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->startVM: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
serviceName = serviceName_example # String | The cloud compute service name
vmName = vmName_example # String | The VM name

try: 
    # Starts a VM and get its associated bare metal compute service.
    api_response = api_instance.start_vm(simid, serviceName, vmName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->startVM: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
service_name*
String
The cloud compute service name
Required
vm_name*
String
The VM name
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


submitCompoundJob

Submit a compound job.


/simulation/{simid}/compoundJobs/{compound_job_name}/submit

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compoundJobs/{compound_job_name}/submit"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Compound_job_name_submit_body body = ; // Compound_job_name_submit_body | Job characteristics.
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            GenericResponse result = apiInstance.submitCompoundJob(body, simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#submitCompoundJob");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Compound_job_name_submit_body body = ; // Compound_job_name_submit_body | Job characteristics.
        String simid = simid_example; // String | ID of the simulation
        String compoundJobName = compoundJobName_example; // String | Name of the compound job
        try {
            GenericResponse result = apiInstance.submitCompoundJob(body, simid, compoundJobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#submitCompoundJob");
            e.printStackTrace();
        }
    }
}
Compound_job_name_submit_body *body = ; // Job characteristics.
String *simid = simid_example; // ID of the simulation
String *compoundJobName = compoundJobName_example; // Name of the compound job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Submit a compound job.
[apiInstance submitCompoundJobWith:body
    simid:simid
    compoundJobName:compoundJobName
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Compound_job_name_submit_body}} Job characteristics.
var simid = simid_example; // {{String}} ID of the simulation
var compoundJobName = compoundJobName_example; // {{String}} Name of the compound job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.submitCompoundJob(bodysimidcompoundJobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class submitCompoundJobExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Compound_job_name_submit_body(); // Compound_job_name_submit_body | Job characteristics.
            var simid = simid_example;  // String | ID of the simulation
            var compoundJobName = compoundJobName_example;  // String | Name of the compound job

            try
            {
                // Submit a compound job.
                GenericResponse result = apiInstance.submitCompoundJob(body, simid, compoundJobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.submitCompoundJob: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Compound_job_name_submit_body | Job characteristics.
$simid = simid_example; // String | ID of the simulation
$compoundJobName = compoundJobName_example; // String | Name of the compound job

try {
    $result = $api_instance->submitCompoundJob($body, $simid, $compoundJobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->submitCompoundJob: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Compound_job_name_submit_body->new(); # Compound_job_name_submit_body | Job characteristics.
my $simid = simid_example; # String | ID of the simulation
my $compoundJobName = compoundJobName_example; # String | Name of the compound job

eval { 
    my $result = $api_instance->submitCompoundJob(body => $body, simid => $simid, compoundJobName => $compoundJobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->submitCompoundJob: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Compound_job_name_submit_body | Job characteristics.
simid = simid_example # String | ID of the simulation
compoundJobName = compoundJobName_example # String | Name of the compound job

try: 
    # Submit a compound job.
    api_response = api_instance.submit_compound_job(body, simid, compoundJobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->submitCompoundJob: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
compound_job_name*
String
Name of the compound job
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 405 - Invalid input


submitStandardJob

Submit a standard job.


/simulation/{simid}/standardJobs/{job_name}/submit

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/standardJobs/{job_name}/submit"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        Job_name_submit_body body = ; // Job_name_submit_body | Job characteristics.
        String simid = simid_example; // String | ID of the simulation
        String jobName = jobName_example; // String | ID of the job
        try {
            GenericResponse result = apiInstance.submitStandardJob(body, simid, jobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#submitStandardJob");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        Job_name_submit_body body = ; // Job_name_submit_body | Job characteristics.
        String simid = simid_example; // String | ID of the simulation
        String jobName = jobName_example; // String | ID of the job
        try {
            GenericResponse result = apiInstance.submitStandardJob(body, simid, jobName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#submitStandardJob");
            e.printStackTrace();
        }
    }
}
Job_name_submit_body *body = ; // Job characteristics.
String *simid = simid_example; // ID of the simulation
String *jobName = jobName_example; // ID of the job

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Submit a standard job.
[apiInstance submitStandardJobWith:body
    simid:simid
    jobName:jobName
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var body = ; // {{Job_name_submit_body}} Job characteristics.
var simid = simid_example; // {{String}} ID of the simulation
var jobName = jobName_example; // {{String}} ID of the job

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.submitStandardJob(bodysimidjobName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class submitStandardJobExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var body = new Job_name_submit_body(); // Job_name_submit_body | Job characteristics.
            var simid = simid_example;  // String | ID of the simulation
            var jobName = jobName_example;  // String | ID of the job

            try
            {
                // Submit a standard job.
                GenericResponse result = apiInstance.submitStandardJob(body, simid, jobName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.submitStandardJob: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$body = ; // Job_name_submit_body | Job characteristics.
$simid = simid_example; // String | ID of the simulation
$jobName = jobName_example; // String | ID of the job

try {
    $result = $api_instance->submitStandardJob($body, $simid, $jobName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->submitStandardJob: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $body = WWW::SwaggerClient::Object::Job_name_submit_body->new(); # Job_name_submit_body | Job characteristics.
my $simid = simid_example; # String | ID of the simulation
my $jobName = jobName_example; # String | ID of the job

eval { 
    my $result = $api_instance->submitStandardJob(body => $body, simid => $simid, jobName => $jobName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->submitStandardJob: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
body =  # Job_name_submit_body | Job characteristics.
simid = simid_example # String | ID of the simulation
jobName = jobName_example # String | ID of the job

try: 
    # Submit a standard job.
    api_response = api_instance.submit_standard_job(body, simid, jobName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->submitStandardJob: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
job_name*
String
ID of the job
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

Status: 405 - Invalid input


supportsCompoundJobs

Returns true if the service supports compound jobs.


/simulation/{simid}/compute_services/{service_name}/supportsCompoundJobs

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compute_services/{service_name}/supportsCompoundJobs"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | Name of the compute service
        try {
            BooleanResponse result = apiInstance.supportsCompoundJobs(simid, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#supportsCompoundJobs");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | Name of the compute service
        try {
            BooleanResponse result = apiInstance.supportsCompoundJobs(simid, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#supportsCompoundJobs");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *serviceName = serviceName_example; // Name of the compute service

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Returns true if the service supports compound jobs.
[apiInstance supportsCompoundJobsWith:simid
    serviceName:serviceName
              completionHandler: ^(BooleanResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var serviceName = serviceName_example; // {{String}} Name of the compute service

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.supportsCompoundJobs(simid, serviceName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class supportsCompoundJobsExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var serviceName = serviceName_example;  // String | Name of the compute service

            try
            {
                // Returns true if the service supports compound jobs.
                BooleanResponse result = apiInstance.supportsCompoundJobs(simid, serviceName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.supportsCompoundJobs: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$serviceName = serviceName_example; // String | Name of the compute service

try {
    $result = $api_instance->supportsCompoundJobs($simid, $serviceName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->supportsCompoundJobs: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $serviceName = serviceName_example; # String | Name of the compute service

eval { 
    my $result = $api_instance->supportsCompoundJobs(simid => $simid, serviceName => $serviceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->supportsCompoundJobs: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
serviceName = serviceName_example # String | Name of the compute service

try: 
    # Returns true if the service supports compound jobs.
    api_response = api_instance.supports_compound_jobs(simid, serviceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->supportsCompoundJobs: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
service_name*
String
Name of the compute service
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


supportsPilotJobs

Returns true if the service supports pilot jobs.


/simulation/{simid}/compute_services/{service_name}/supportsPilotJobs

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compute_services/{service_name}/supportsPilotJobs"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | Name of the compute service
        try {
            BooleanResponse result = apiInstance.supportsPilotJobs(simid, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#supportsPilotJobs");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | Name of the compute service
        try {
            BooleanResponse result = apiInstance.supportsPilotJobs(simid, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#supportsPilotJobs");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *serviceName = serviceName_example; // Name of the compute service

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Returns true if the service supports pilot jobs.
[apiInstance supportsPilotJobsWith:simid
    serviceName:serviceName
              completionHandler: ^(BooleanResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var serviceName = serviceName_example; // {{String}} Name of the compute service

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.supportsPilotJobs(simid, serviceName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class supportsPilotJobsExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var serviceName = serviceName_example;  // String | Name of the compute service

            try
            {
                // Returns true if the service supports pilot jobs.
                BooleanResponse result = apiInstance.supportsPilotJobs(simid, serviceName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.supportsPilotJobs: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$serviceName = serviceName_example; // String | Name of the compute service

try {
    $result = $api_instance->supportsPilotJobs($simid, $serviceName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->supportsPilotJobs: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $serviceName = serviceName_example; # String | Name of the compute service

eval { 
    my $result = $api_instance->supportsPilotJobs(simid => $simid, serviceName => $serviceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->supportsPilotJobs: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
serviceName = serviceName_example # String | Name of the compute service

try: 
    # Returns true if the service supports pilot jobs.
    api_response = api_instance.supports_pilot_jobs(simid, serviceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->supportsPilotJobs: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
service_name*
String
Name of the compute service
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


supportsStandardJobs

Returns true if the service supports standard jobs.


/simulation/{simid}/compute_services/{service_name}/supportsStandardJobs

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/compute_services/{service_name}/supportsStandardJobs"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | Name of the compute service
        try {
            BooleanResponse result = apiInstance.supportsStandardJobs(simid, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#supportsStandardJobs");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | Name of the compute service
        try {
            BooleanResponse result = apiInstance.supportsStandardJobs(simid, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#supportsStandardJobs");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *serviceName = serviceName_example; // Name of the compute service

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Returns true if the service supports standard jobs.
[apiInstance supportsStandardJobsWith:simid
    serviceName:serviceName
              completionHandler: ^(BooleanResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var serviceName = serviceName_example; // {{String}} Name of the compute service

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.supportsStandardJobs(simid, serviceName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class supportsStandardJobsExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var serviceName = serviceName_example;  // String | Name of the compute service

            try
            {
                // Returns true if the service supports standard jobs.
                BooleanResponse result = apiInstance.supportsStandardJobs(simid, serviceName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.supportsStandardJobs: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$serviceName = serviceName_example; // String | Name of the compute service

try {
    $result = $api_instance->supportsStandardJobs($simid, $serviceName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->supportsStandardJobs: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $serviceName = serviceName_example; # String | Name of the compute service

eval { 
    my $result = $api_instance->supportsStandardJobs(simid => $simid, serviceName => $serviceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->supportsStandardJobs: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
serviceName = serviceName_example # String | Name of the compute service

try: 
    # Returns true if the service supports standard jobs.
    api_response = api_instance.supports_standard_jobs(simid, serviceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->supportsStandardJobs: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
service_name*
String
Name of the compute service
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


suspendVM

Suspends a running VM.


/simulation/{simid}/cloud_compute_services/{service_name}/vms/{vm_name}/suspendVM

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/cloud_compute_services/{service_name}/vms/{vm_name}/suspendVM"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The cloud compute service name
        String vmName = vmName_example; // String | The VM name
        try {
            GenericResponse result = apiInstance.suspendVM(simid, serviceName, vmName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#suspendVM");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String serviceName = serviceName_example; // String | The cloud compute service name
        String vmName = vmName_example; // String | The VM name
        try {
            GenericResponse result = apiInstance.suspendVM(simid, serviceName, vmName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#suspendVM");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *serviceName = serviceName_example; // The cloud compute service name
String *vmName = vmName_example; // The VM name

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Suspends a running VM.
[apiInstance suspendVMWith:simid
    serviceName:serviceName
    vmName:vmName
              completionHandler: ^(GenericResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var serviceName = serviceName_example; // {{String}} The cloud compute service name
var vmName = vmName_example; // {{String}} The VM name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.suspendVM(simid, serviceName, vmName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class suspendVMExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var serviceName = serviceName_example;  // String | The cloud compute service name
            var vmName = vmName_example;  // String | The VM name

            try
            {
                // Suspends a running VM.
                GenericResponse result = apiInstance.suspendVM(simid, serviceName, vmName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.suspendVM: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$serviceName = serviceName_example; // String | The cloud compute service name
$vmName = vmName_example; // String | The VM name

try {
    $result = $api_instance->suspendVM($simid, $serviceName, $vmName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->suspendVM: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $serviceName = serviceName_example; # String | The cloud compute service name
my $vmName = vmName_example; # String | The VM name

eval { 
    my $result = $api_instance->suspendVM(simid => $simid, serviceName => $serviceName, vmName => $vmName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->suspendVM: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
serviceName = serviceName_example # String | The cloud compute service name
vmName = vmName_example # String | The VM name

try: 
    # Suspends a running VM.
    api_response = api_instance.suspend_vm(simid, serviceName, vmName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->suspendVM: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
service_name*
String
The cloud compute service name
Required
vm_name*
String
The VM name
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


waitForNextSimulationEvent

Retrieve the next simulation event.


/simulation/{simid}/waitForNextSimulationEvent

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/waitForNextSimulationEvent"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        try {
            Event result = apiInstance.waitForNextSimulationEvent(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#waitForNextSimulationEvent");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        try {
            Event result = apiInstance.waitForNextSimulationEvent(simid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#waitForNextSimulationEvent");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Retrieve the next simulation event.
[apiInstance waitForNextSimulationEventWith:simid
              completionHandler: ^(Event output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.waitForNextSimulationEvent(simid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class waitForNextSimulationEventExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation

            try
            {
                // Retrieve the next simulation event.
                Event result = apiInstance.waitForNextSimulationEvent(simid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.waitForNextSimulationEvent: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation

try {
    $result = $api_instance->waitForNextSimulationEvent($simid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->waitForNextSimulationEvent: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation

eval { 
    my $result = $api_instance->waitForNextSimulationEvent(simid => $simid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->waitForNextSimulationEvent: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation

try: 
    # Retrieve the next simulation event.
    api_response = api_instance.wait_for_next_simulation_event(simid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->waitForNextSimulationEvent: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required

Responses

Status: 200 - OK

Status: 405 - Invalid input


workflowIsDone

Return whether the workflow has finished executing or not.


/simulation/{simid}/workflows/{workflow_name}/isDone

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://wrench-project.org/v1/simulation/{simid}/workflows/{workflow_name}/isDone"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WRENCHApi;

import java.io.File;
import java.util.*;

public class WRENCHApiExample {

    public static void main(String[] args) {
        
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        try {
            BooleanResponse result = apiInstance.workflowIsDone(simid, workflowName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#workflowIsDone");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WRENCHApi;

public class WRENCHApiExample {

    public static void main(String[] args) {
        WRENCHApi apiInstance = new WRENCHApi();
        String simid = simid_example; // String | ID of the simulation
        String workflowName = workflowName_example; // String | 
        try {
            BooleanResponse result = apiInstance.workflowIsDone(simid, workflowName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WRENCHApi#workflowIsDone");
            e.printStackTrace();
        }
    }
}
String *simid = simid_example; // ID of the simulation
String *workflowName = workflowName_example; // 

WRENCHApi *apiInstance = [[WRENCHApi alloc] init];

// Return whether the workflow has finished executing or not.
[apiInstance workflowIsDoneWith:simid
    workflowName:workflowName
              completionHandler: ^(BooleanResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WrenchRestApi = require('wrench_rest_api');

var api = new WrenchRestApi.WRENCHApi()
var simid = simid_example; // {{String}} ID of the simulation
var workflowName = workflowName_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.workflowIsDone(simid, workflowName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class workflowIsDoneExample
    {
        public void main()
        {

            var apiInstance = new WRENCHApi();
            var simid = simid_example;  // String | ID of the simulation
            var workflowName = workflowName_example;  // String | 

            try
            {
                // Return whether the workflow has finished executing or not.
                BooleanResponse result = apiInstance.workflowIsDone(simid, workflowName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WRENCHApi.workflowIsDone: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiWRENCHApi();
$simid = simid_example; // String | ID of the simulation
$workflowName = workflowName_example; // String | 

try {
    $result = $api_instance->workflowIsDone($simid, $workflowName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WRENCHApi->workflowIsDone: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WRENCHApi;

my $api_instance = WWW::SwaggerClient::WRENCHApi->new();
my $simid = simid_example; # String | ID of the simulation
my $workflowName = workflowName_example; # String | 

eval { 
    my $result = $api_instance->workflowIsDone(simid => $simid, workflowName => $workflowName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WRENCHApi->workflowIsDone: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.WRENCHApi()
simid = simid_example # String | ID of the simulation
workflowName = workflowName_example # String | 

try: 
    # Return whether the workflow has finished executing or not.
    api_response = api_instance.workflow_is_done(simid, workflowName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WRENCHApi->workflowIsDone: %s\n" % e)

Parameters

Path parameters
Name Description
simid*
String
ID of the simulation
Required
workflow_name*
String
Required

Responses

Status: 200 - OK

Status: 404 - Task not found

Status: 405 - Invalid input