SO Guilin APIs

E2eServiceInstances

activateE2EServiceInstances

Activate/Deactivate 5G slice Service on a specified version and serviceId


/onap/so/infra/e2eServiceInstances/{version}/{serviceId}/{operationType}

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/e2eServiceInstances/{version}/{serviceId}/{operationType}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.E2eServiceInstancesApi;

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

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String version = version_example; // String | 
        String serviceId = serviceId_example; // String | 
        String operationType = operationType_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.activateE2EServiceInstances(version, serviceId, operationType, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#activateE2EServiceInstances");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.E2eServiceInstancesApi;

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String version = version_example; // String | 
        String serviceId = serviceId_example; // String | 
        String operationType = operationType_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.activateE2EServiceInstances(version, serviceId, operationType, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#activateE2EServiceInstances");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceId = serviceId_example; // 
String *operationType = operationType_example; // 
String *body = body_example; //  (optional)

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

// Activate/Deactivate 5G slice Service on a specified version and serviceId
[apiInstance activateE2EServiceInstancesWith:version
    serviceId:serviceId
    operationType:operationType
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.E2eServiceInstancesApi()

var version = version_example; // {String} 

var serviceId = serviceId_example; // {String} 

var operationType = operationType_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.activateE2EServiceInstances(version, serviceId, operationType, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activateE2EServiceInstancesExample
    {
        public void main()
        {
            
            var apiInstance = new E2eServiceInstancesApi();
            var version = version_example;  // String | 
            var serviceId = serviceId_example;  // String | 
            var operationType = operationType_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Activate/Deactivate 5G slice Service on a specified version and serviceId
                apiInstance.activateE2EServiceInstances(version, serviceId, operationType, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling E2eServiceInstancesApi.activateE2EServiceInstances: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\E2eServiceInstancesApi();
$version = version_example; // String | 
$serviceId = serviceId_example; // String | 
$operationType = operationType_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->activateE2EServiceInstances($version, $serviceId, $operationType, $body);
} catch (Exception $e) {
    echo 'Exception when calling E2eServiceInstancesApi->activateE2EServiceInstances: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::E2eServiceInstancesApi;

my $api_instance = WWW::SwaggerClient::E2eServiceInstancesApi->new();
my $version = version_example; # String | 
my $serviceId = serviceId_example; # String | 
my $operationType = operationType_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->activateE2EServiceInstances(version => $version, serviceId => $serviceId, operationType => $operationType, body => $body);
};
if ($@) {
    warn "Exception when calling E2eServiceInstancesApi->activateE2EServiceInstances: $@\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.E2eServiceInstancesApi()
version = version_example # String | 
serviceId = serviceId_example # String | 
operationType = operationType_example # String | 
body = body_example # String |  (optional)

try: 
    # Activate/Deactivate 5G slice Service on a specified version and serviceId
    api_instance.activate_e2_e_service_instances(version, serviceId, operationType, body=body)
except ApiException as e:
    print("Exception when calling E2eServiceInstancesApi->activateE2EServiceInstances: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceId*
String
Required
operationType*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


compareModelwithTargetVersion

Find added and deleted resources of target model for the e2eserviceInstance on a given serviceId


/onap/so/infra/e2eServiceInstances/{version}/{serviceId}/modeldifferences

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/e2eServiceInstances/{version}/{serviceId}/modeldifferences"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.E2eServiceInstancesApi;

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

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String serviceId = serviceId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.compareModelwithTargetVersion(serviceId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#compareModelwithTargetVersion");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.E2eServiceInstancesApi;

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String serviceId = serviceId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.compareModelwithTargetVersion(serviceId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#compareModelwithTargetVersion");
            e.printStackTrace();
        }
    }
}
String *serviceId = serviceId_example; // 
String *version = version_example; // 
String *body = body_example; //  (optional)

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

// Find added and deleted resources of target model for the e2eserviceInstance on a given serviceId
[apiInstance compareModelwithTargetVersionWith:serviceId
    version:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.E2eServiceInstancesApi()

var serviceId = serviceId_example; // {String} 

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.compareModelwithTargetVersion(serviceId, version, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class compareModelwithTargetVersionExample
    {
        public void main()
        {
            
            var apiInstance = new E2eServiceInstancesApi();
            var serviceId = serviceId_example;  // String | 
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Find added and deleted resources of target model for the e2eserviceInstance on a given serviceId
                apiInstance.compareModelwithTargetVersion(serviceId, version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling E2eServiceInstancesApi.compareModelwithTargetVersion: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\E2eServiceInstancesApi();
$serviceId = serviceId_example; // String | 
$version = version_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->compareModelwithTargetVersion($serviceId, $version, $body);
} catch (Exception $e) {
    echo 'Exception when calling E2eServiceInstancesApi->compareModelwithTargetVersion: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::E2eServiceInstancesApi;

my $api_instance = WWW::SwaggerClient::E2eServiceInstancesApi->new();
my $serviceId = serviceId_example; # String | 
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->compareModelwithTargetVersion(serviceId => $serviceId, version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling E2eServiceInstancesApi->compareModelwithTargetVersion: $@\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.E2eServiceInstancesApi()
serviceId = serviceId_example # String | 
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # Find added and deleted resources of target model for the e2eserviceInstance on a given serviceId
    api_instance.compare_modelwith_target_version(serviceId, version, body=body)
except ApiException as e:
    print("Exception when calling E2eServiceInstancesApi->compareModelwithTargetVersion: %s\n" % e)

Parameters

Path parameters
Name Description
serviceId*
String
Required
version*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


createE2EServiceInstance

Create an E2E Service Instance on a version provided


/onap/so/infra/e2eServiceInstances/{version}

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/e2eServiceInstances/{version}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.E2eServiceInstancesApi;

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

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createE2EServiceInstance(version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#createE2EServiceInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.E2eServiceInstancesApi;

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createE2EServiceInstance(version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#createE2EServiceInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *body = body_example; //  (optional)

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

// Create an E2E Service Instance on a version provided
[apiInstance createE2EServiceInstanceWith:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.E2eServiceInstancesApi()

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createE2EServiceInstance(version, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createE2EServiceInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new E2eServiceInstancesApi();
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Create an E2E Service Instance on a version provided
                apiInstance.createE2EServiceInstance(version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling E2eServiceInstancesApi.createE2EServiceInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\E2eServiceInstancesApi();
$version = version_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->createE2EServiceInstance($version, $body);
} catch (Exception $e) {
    echo 'Exception when calling E2eServiceInstancesApi->createE2EServiceInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::E2eServiceInstancesApi;

my $api_instance = WWW::SwaggerClient::E2eServiceInstancesApi->new();
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->createE2EServiceInstance(version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling E2eServiceInstancesApi->createE2EServiceInstance: $@\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.E2eServiceInstancesApi()
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # Create an E2E Service Instance on a version provided
    api_instance.create_e2_e_service_instance(version, body=body)
except ApiException as e:
    print("Exception when calling E2eServiceInstancesApi->createE2EServiceInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


deleteE2EServiceInstance

Delete E2E Service Instance on a specified version and serviceId


/onap/so/infra/e2eServiceInstances/{version}/{serviceId}

Usage and SDK Samples

curl -X DELETE "http://localhost/onap/so/infra/e2eServiceInstances/{version}/{serviceId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.E2eServiceInstancesApi;

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

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String version = version_example; // String | 
        String serviceId = serviceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteE2EServiceInstance(version, serviceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#deleteE2EServiceInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.E2eServiceInstancesApi;

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String version = version_example; // String | 
        String serviceId = serviceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteE2EServiceInstance(version, serviceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#deleteE2EServiceInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceId = serviceId_example; // 
String *body = body_example; //  (optional)

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

// Delete E2E Service Instance on a specified version and serviceId
[apiInstance deleteE2EServiceInstanceWith:version
    serviceId:serviceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.E2eServiceInstancesApi()

var version = version_example; // {String} 

var serviceId = serviceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteE2EServiceInstance(version, serviceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteE2EServiceInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new E2eServiceInstancesApi();
            var version = version_example;  // String | 
            var serviceId = serviceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Delete E2E Service Instance on a specified version and serviceId
                apiInstance.deleteE2EServiceInstance(version, serviceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling E2eServiceInstancesApi.deleteE2EServiceInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\E2eServiceInstancesApi();
$version = version_example; // String | 
$serviceId = serviceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deleteE2EServiceInstance($version, $serviceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling E2eServiceInstancesApi->deleteE2EServiceInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::E2eServiceInstancesApi;

my $api_instance = WWW::SwaggerClient::E2eServiceInstancesApi->new();
my $version = version_example; # String | 
my $serviceId = serviceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deleteE2EServiceInstance(version => $version, serviceId => $serviceId, body => $body);
};
if ($@) {
    warn "Exception when calling E2eServiceInstancesApi->deleteE2EServiceInstance: $@\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.E2eServiceInstancesApi()
version = version_example # String | 
serviceId = serviceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Delete E2E Service Instance on a specified version and serviceId
    api_instance.delete_e2_e_service_instance(version, serviceId, body=body)
except ApiException as e:
    print("Exception when calling E2eServiceInstancesApi->deleteE2EServiceInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


getE2EServiceInstances

Find e2eServiceInstances Requests for a given serviceId and operationId


/onap/so/infra/e2eServiceInstances/{version}/{serviceId}/operations/{operationId}

Usage and SDK Samples

curl -X GET "http://localhost/onap/so/infra/e2eServiceInstances/{version}/{serviceId}/operations/{operationId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.E2eServiceInstancesApi;

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

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String serviceId = serviceId_example; // String | 
        String version = version_example; // String | 
        String operationId = operationId_example; // String | 
        try {
            apiInstance.getE2EServiceInstances(serviceId, version, operationId);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#getE2EServiceInstances");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.E2eServiceInstancesApi;

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String serviceId = serviceId_example; // String | 
        String version = version_example; // String | 
        String operationId = operationId_example; // String | 
        try {
            apiInstance.getE2EServiceInstances(serviceId, version, operationId);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#getE2EServiceInstances");
            e.printStackTrace();
        }
    }
}
String *serviceId = serviceId_example; // 
String *version = version_example; // 
String *operationId = operationId_example; // 

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

// Find e2eServiceInstances Requests for a given serviceId and operationId
[apiInstance getE2EServiceInstancesWith:serviceId
    version:version
    operationId:operationId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.E2eServiceInstancesApi()

var serviceId = serviceId_example; // {String} 

var version = version_example; // {String} 

var operationId = operationId_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getE2EServiceInstances(serviceId, version, operationId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getE2EServiceInstancesExample
    {
        public void main()
        {
            
            var apiInstance = new E2eServiceInstancesApi();
            var serviceId = serviceId_example;  // String | 
            var version = version_example;  // String | 
            var operationId = operationId_example;  // String | 

            try
            {
                // Find e2eServiceInstances Requests for a given serviceId and operationId
                apiInstance.getE2EServiceInstances(serviceId, version, operationId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling E2eServiceInstancesApi.getE2EServiceInstances: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\E2eServiceInstancesApi();
$serviceId = serviceId_example; // String | 
$version = version_example; // String | 
$operationId = operationId_example; // String | 

try {
    $api_instance->getE2EServiceInstances($serviceId, $version, $operationId);
} catch (Exception $e) {
    echo 'Exception when calling E2eServiceInstancesApi->getE2EServiceInstances: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::E2eServiceInstancesApi;

my $api_instance = WWW::SwaggerClient::E2eServiceInstancesApi->new();
my $serviceId = serviceId_example; # String | 
my $version = version_example; # String | 
my $operationId = operationId_example; # String | 

eval { 
    $api_instance->getE2EServiceInstances(serviceId => $serviceId, version => $version, operationId => $operationId);
};
if ($@) {
    warn "Exception when calling E2eServiceInstancesApi->getE2EServiceInstances: $@\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.E2eServiceInstancesApi()
serviceId = serviceId_example # String | 
version = version_example # String | 
operationId = operationId_example # String | 

try: 
    # Find e2eServiceInstances Requests for a given serviceId and operationId
    api_instance.get_e2_e_service_instances(serviceId, version, operationId)
except ApiException as e:
    print("Exception when calling E2eServiceInstancesApi->getE2EServiceInstances: %s\n" % e)

Parameters

Path parameters
Name Description
serviceId*
String
Required
version*
String
Required
operationId*
String
Required

Responses

Status: default - successful operation


scaleE2EServiceInstance

Scale E2E Service Instance on a specified version


/onap/so/infra/e2eServiceInstances/{version}/{serviceId}/scale

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/e2eServiceInstances/{version}/{serviceId}/scale"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.E2eServiceInstancesApi;

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

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String version = version_example; // String | 
        String serviceId = serviceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.scaleE2EServiceInstance(version, serviceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#scaleE2EServiceInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.E2eServiceInstancesApi;

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String version = version_example; // String | 
        String serviceId = serviceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.scaleE2EServiceInstance(version, serviceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#scaleE2EServiceInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceId = serviceId_example; // 
String *body = body_example; //  (optional)

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

// Scale E2E Service Instance on a specified version
[apiInstance scaleE2EServiceInstanceWith:version
    serviceId:serviceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.E2eServiceInstancesApi()

var version = version_example; // {String} 

var serviceId = serviceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.scaleE2EServiceInstance(version, serviceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class scaleE2EServiceInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new E2eServiceInstancesApi();
            var version = version_example;  // String | 
            var serviceId = serviceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Scale E2E Service Instance on a specified version
                apiInstance.scaleE2EServiceInstance(version, serviceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling E2eServiceInstancesApi.scaleE2EServiceInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\E2eServiceInstancesApi();
$version = version_example; // String | 
$serviceId = serviceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->scaleE2EServiceInstance($version, $serviceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling E2eServiceInstancesApi->scaleE2EServiceInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::E2eServiceInstancesApi;

my $api_instance = WWW::SwaggerClient::E2eServiceInstancesApi->new();
my $version = version_example; # String | 
my $serviceId = serviceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->scaleE2EServiceInstance(version => $version, serviceId => $serviceId, body => $body);
};
if ($@) {
    warn "Exception when calling E2eServiceInstancesApi->scaleE2EServiceInstance: $@\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.E2eServiceInstancesApi()
version = version_example # String | 
serviceId = serviceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Scale E2E Service Instance on a specified version
    api_instance.scale_e2_e_service_instance(version, serviceId, body=body)
except ApiException as e:
    print("Exception when calling E2eServiceInstancesApi->scaleE2EServiceInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


updateE2EServiceInstance

Update an E2E Service Instance on a version provided and serviceId


/onap/so/infra/e2eServiceInstances/{version}/{serviceId}

Usage and SDK Samples

curl -X PUT "http://localhost/onap/so/infra/e2eServiceInstances/{version}/{serviceId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.E2eServiceInstancesApi;

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

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String version = version_example; // String | 
        String serviceId = serviceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateE2EServiceInstance(version, serviceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#updateE2EServiceInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.E2eServiceInstancesApi;

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String version = version_example; // String | 
        String serviceId = serviceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateE2EServiceInstance(version, serviceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#updateE2EServiceInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceId = serviceId_example; // 
String *body = body_example; //  (optional)

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

// Update an E2E Service Instance on a version provided and serviceId
[apiInstance updateE2EServiceInstanceWith:version
    serviceId:serviceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.E2eServiceInstancesApi()

var version = version_example; // {String} 

var serviceId = serviceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateE2EServiceInstance(version, serviceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class updateE2EServiceInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new E2eServiceInstancesApi();
            var version = version_example;  // String | 
            var serviceId = serviceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Update an E2E Service Instance on a version provided and serviceId
                apiInstance.updateE2EServiceInstance(version, serviceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling E2eServiceInstancesApi.updateE2EServiceInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\E2eServiceInstancesApi();
$version = version_example; // String | 
$serviceId = serviceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->updateE2EServiceInstance($version, $serviceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling E2eServiceInstancesApi->updateE2EServiceInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::E2eServiceInstancesApi;

my $api_instance = WWW::SwaggerClient::E2eServiceInstancesApi->new();
my $version = version_example; # String | 
my $serviceId = serviceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->updateE2EServiceInstance(version => $version, serviceId => $serviceId, body => $body);
};
if ($@) {
    warn "Exception when calling E2eServiceInstancesApi->updateE2EServiceInstance: $@\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.E2eServiceInstancesApi()
version = version_example # String | 
serviceId = serviceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Update an E2E Service Instance on a version provided and serviceId
    api_instance.update_e2_e_service_instance(version, serviceId, body=body)
except ApiException as e:
    print("Exception when calling E2eServiceInstancesApi->updateE2EServiceInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


Globalhealthcheck

globalHealthcheck

Performing global health check


/globalhealthcheck

Usage and SDK Samples

curl -X GET "http://localhost/globalhealthcheck?enableBpmn="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlobalhealthcheckApi;

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

public class GlobalhealthcheckApiExample {

    public static void main(String[] args) {
        
        GlobalhealthcheckApi apiInstance = new GlobalhealthcheckApi();
        Boolean enableBpmn = true; // Boolean | 
        try {
            apiInstance.globalHealthcheck(enableBpmn);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlobalhealthcheckApi#globalHealthcheck");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.GlobalhealthcheckApi;

public class GlobalhealthcheckApiExample {

    public static void main(String[] args) {
        GlobalhealthcheckApi apiInstance = new GlobalhealthcheckApi();
        Boolean enableBpmn = true; // Boolean | 
        try {
            apiInstance.globalHealthcheck(enableBpmn);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlobalhealthcheckApi#globalHealthcheck");
            e.printStackTrace();
        }
    }
}
Boolean *enableBpmn = true; //  (optional) (default to true)

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

// Performing global health check
[apiInstance globalHealthcheckWith:enableBpmn
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.GlobalhealthcheckApi()

var opts = { 
  'enableBpmn': true // {Boolean} 
};

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

namespace Example
{
    public class globalHealthcheckExample
    {
        public void main()
        {
            
            var apiInstance = new GlobalhealthcheckApi();
            var enableBpmn = true;  // Boolean |  (optional)  (default to true)

            try
            {
                // Performing global health check
                apiInstance.globalHealthcheck(enableBpmn);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlobalhealthcheckApi.globalHealthcheck: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\GlobalhealthcheckApi();
$enableBpmn = true; // Boolean | 

try {
    $api_instance->globalHealthcheck($enableBpmn);
} catch (Exception $e) {
    echo 'Exception when calling GlobalhealthcheckApi->globalHealthcheck: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlobalhealthcheckApi;

my $api_instance = WWW::SwaggerClient::GlobalhealthcheckApi->new();
my $enableBpmn = true; # Boolean | 

eval { 
    $api_instance->globalHealthcheck(enableBpmn => $enableBpmn);
};
if ($@) {
    warn "Exception when calling GlobalhealthcheckApi->globalHealthcheck: $@\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.GlobalhealthcheckApi()
enableBpmn = true # Boolean |  (optional) (default to true)

try: 
    # Performing global health check
    api_instance.global_healthcheck(enableBpmn=enableBpmn)
except ApiException as e:
    print("Exception when calling GlobalhealthcheckApi->globalHealthcheck: %s\n" % e)

Parameters

Query parameters
Name Description
enableBpmn
Boolean

Responses

Status: default - successful operation


Nodehealthcheck

nodeHealthcheck

Performing node health check


/nodehealthcheck

Usage and SDK Samples

curl -X GET "http://localhost/nodehealthcheck"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NodehealthcheckApi;

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

public class NodehealthcheckApiExample {

    public static void main(String[] args) {
        
        NodehealthcheckApi apiInstance = new NodehealthcheckApi();
        try {
            apiInstance.nodeHealthcheck();
        } catch (ApiException e) {
            System.err.println("Exception when calling NodehealthcheckApi#nodeHealthcheck");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NodehealthcheckApi;

public class NodehealthcheckApiExample {

    public static void main(String[] args) {
        NodehealthcheckApi apiInstance = new NodehealthcheckApi();
        try {
            apiInstance.nodeHealthcheck();
        } catch (ApiException e) {
            System.err.println("Exception when calling NodehealthcheckApi#nodeHealthcheck");
            e.printStackTrace();
        }
    }
}

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

// Performing node health check
[apiInstance nodeHealthcheckWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.NodehealthcheckApi()

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

namespace Example
{
    public class nodeHealthcheckExample
    {
        public void main()
        {
            
            var apiInstance = new NodehealthcheckApi();

            try
            {
                // Performing node health check
                apiInstance.nodeHealthcheck();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NodehealthcheckApi.nodeHealthcheck: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\NodehealthcheckApi();

try {
    $api_instance->nodeHealthcheck();
} catch (Exception $e) {
    echo 'Exception when calling NodehealthcheckApi->nodeHealthcheck: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NodehealthcheckApi;

my $api_instance = WWW::SwaggerClient::NodehealthcheckApi->new();

eval { 
    $api_instance->nodeHealthcheck();
};
if ($@) {
    warn "Exception when calling NodehealthcheckApi->nodeHealthcheck: $@\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.NodehealthcheckApi()

try: 
    # Performing node health check
    api_instance.node_healthcheck()
except ApiException as e:
    print("Exception when calling NodehealthcheckApi->nodeHealthcheck: %s\n" % e)

Parameters

Responses

Status: default - successful operation


Onap3gppServiceInstances

activate3gppService

Activate a 3GPP Service Instance on a version provided


/onap/so/infra/3gppservices/{version}/activate

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/3gppservices/{version}/activate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Onap3gppServiceInstancesApi;

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

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        3gppServiceActivation body = ; // 3gppServiceActivation | 
        String version = version_example; // String | 
        try {
            3gppServiceResponse result = apiInstance.activate3gppService(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#activate3gppService");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Onap3gppServiceInstancesApi;

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        3gppServiceActivation body = ; // 3gppServiceActivation | 
        String version = version_example; // String | 
        try {
            3gppServiceResponse result = apiInstance.activate3gppService(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#activate3gppService");
            e.printStackTrace();
        }
    }
}
3gppServiceActivation *body = ; // 
String *version = version_example; // 

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

// Activate a 3GPP Service Instance on a version provided
[apiInstance activate3gppServiceWith:body
    version:version
              completionHandler: ^(3gppServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.Onap3gppServiceInstancesApi()

var body = ; // {3gppServiceActivation} 

var version = version_example; // {String} 


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

namespace Example
{
    public class activate3gppServiceExample
    {
        public void main()
        {
            
            var apiInstance = new Onap3gppServiceInstancesApi();
            var body = new 3gppServiceActivation(); // 3gppServiceActivation | 
            var version = version_example;  // String | 

            try
            {
                // Activate a 3GPP Service Instance on a version provided
                3gppServiceResponse result = apiInstance.activate3gppService(body, version);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Onap3gppServiceInstancesApi.activate3gppService: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\Onap3gppServiceInstancesApi();
$body = ; // 3gppServiceActivation | 
$version = version_example; // String | 

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

my $api_instance = WWW::SwaggerClient::Onap3gppServiceInstancesApi->new();
my $body = WWW::SwaggerClient::Object::3gppServiceActivation->new(); # 3gppServiceActivation | 
my $version = version_example; # String | 

eval { 
    my $result = $api_instance->activate3gppService(body => $body, version => $version);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Onap3gppServiceInstancesApi->activate3gppService: $@\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.Onap3gppServiceInstancesApi()
body =  # 3gppServiceActivation | 
version = version_example # String | 

try: 
    # Activate a 3GPP Service Instance on a version provided
    api_response = api_instance.activate3gpp_service(body, version)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Onap3gppServiceInstancesApi->activate3gppService: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
Body parameters
Name Description
body *

Responses

Status: default - successful operation


allocate3gppService

Create a 3GPP Service Instance on a version provided


/onap/so/infra/3gppservices/{version}/allocate

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/3gppservices/{version}/allocate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Onap3gppServiceInstancesApi;

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

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        Allocate3gppService body = ; // Allocate3gppService | 
        String version = version_example; // String | 
        try {
            3gppServiceResponse result = apiInstance.allocate3gppService(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#allocate3gppService");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Onap3gppServiceInstancesApi;

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        Allocate3gppService body = ; // Allocate3gppService | 
        String version = version_example; // String | 
        try {
            3gppServiceResponse result = apiInstance.allocate3gppService(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#allocate3gppService");
            e.printStackTrace();
        }
    }
}
Allocate3gppService *body = ; // 
String *version = version_example; // 

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

// Create a 3GPP Service Instance on a version provided
[apiInstance allocate3gppServiceWith:body
    version:version
              completionHandler: ^(3gppServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.Onap3gppServiceInstancesApi()

var body = ; // {Allocate3gppService} 

var version = version_example; // {String} 


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

namespace Example
{
    public class allocate3gppServiceExample
    {
        public void main()
        {
            
            var apiInstance = new Onap3gppServiceInstancesApi();
            var body = new Allocate3gppService(); // Allocate3gppService | 
            var version = version_example;  // String | 

            try
            {
                // Create a 3GPP Service Instance on a version provided
                3gppServiceResponse result = apiInstance.allocate3gppService(body, version);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Onap3gppServiceInstancesApi.allocate3gppService: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\Onap3gppServiceInstancesApi();
$body = ; // Allocate3gppService | 
$version = version_example; // String | 

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

my $api_instance = WWW::SwaggerClient::Onap3gppServiceInstancesApi->new();
my $body = WWW::SwaggerClient::Object::Allocate3gppService->new(); # Allocate3gppService | 
my $version = version_example; # String | 

eval { 
    my $result = $api_instance->allocate3gppService(body => $body, version => $version);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Onap3gppServiceInstancesApi->allocate3gppService: $@\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.Onap3gppServiceInstancesApi()
body =  # Allocate3gppService | 
version = version_example # String | 

try: 
    # Create a 3GPP Service Instance on a version provided
    api_response = api_instance.allocate3gpp_service(body, version)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Onap3gppServiceInstancesApi->allocate3gppService: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
Body parameters
Name Description
body *

Responses

Status: default - successful operation


deactivate3gppService

Deactivate a 3GPP Service Instance on a version provided


/onap/so/infra/3gppservices/{version}/deActivate

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/3gppservices/{version}/deActivate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Onap3gppServiceInstancesApi;

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

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        3gppServiceActivation body = ; // 3gppServiceActivation | 
        String version = version_example; // String | 
        try {
            3gppServiceResponse result = apiInstance.deactivate3gppService(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#deactivate3gppService");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Onap3gppServiceInstancesApi;

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        3gppServiceActivation body = ; // 3gppServiceActivation | 
        String version = version_example; // String | 
        try {
            3gppServiceResponse result = apiInstance.deactivate3gppService(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#deactivate3gppService");
            e.printStackTrace();
        }
    }
}
3gppServiceActivation *body = ; // 
String *version = version_example; // 

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

// Deactivate a 3GPP Service Instance on a version provided
[apiInstance deactivate3gppServiceWith:body
    version:version
              completionHandler: ^(3gppServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.Onap3gppServiceInstancesApi()

var body = ; // {3gppServiceActivation} 

var version = version_example; // {String} 


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

namespace Example
{
    public class deactivate3gppServiceExample
    {
        public void main()
        {
            
            var apiInstance = new Onap3gppServiceInstancesApi();
            var body = new 3gppServiceActivation(); // 3gppServiceActivation | 
            var version = version_example;  // String | 

            try
            {
                // Deactivate a 3GPP Service Instance on a version provided
                3gppServiceResponse result = apiInstance.deactivate3gppService(body, version);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Onap3gppServiceInstancesApi.deactivate3gppService: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\Onap3gppServiceInstancesApi();
$body = ; // 3gppServiceActivation | 
$version = version_example; // String | 

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

my $api_instance = WWW::SwaggerClient::Onap3gppServiceInstancesApi->new();
my $body = WWW::SwaggerClient::Object::3gppServiceActivation->new(); # 3gppServiceActivation | 
my $version = version_example; # String | 

eval { 
    my $result = $api_instance->deactivate3gppService(body => $body, version => $version);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Onap3gppServiceInstancesApi->deactivate3gppService: $@\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.Onap3gppServiceInstancesApi()
body =  # 3gppServiceActivation | 
version = version_example # String | 

try: 
    # Deactivate a 3GPP Service Instance on a version provided
    api_response = api_instance.deactivate3gpp_service(body, version)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Onap3gppServiceInstancesApi->deactivate3gppService: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
Body parameters
Name Description
body *

Responses

Status: default - successful operation


deallocate3gppService

Terminate/Deallocate a 3GPP Service Instance on a version provided


/onap/so/infra/3gppservices/{version}/deAllocate

Usage and SDK Samples

curl -X DELETE "http://localhost/onap/so/infra/3gppservices/{version}/deAllocate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Onap3gppServiceInstancesApi;

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

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        DeAllocate3gppService body = ; // DeAllocate3gppService | 
        String version = version_example; // String | 
        try {
            3gppServiceResponse result = apiInstance.deallocate3gppService(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#deallocate3gppService");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Onap3gppServiceInstancesApi;

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        DeAllocate3gppService body = ; // DeAllocate3gppService | 
        String version = version_example; // String | 
        try {
            3gppServiceResponse result = apiInstance.deallocate3gppService(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#deallocate3gppService");
            e.printStackTrace();
        }
    }
}
DeAllocate3gppService *body = ; // 
String *version = version_example; // 

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

// Terminate/Deallocate a 3GPP Service Instance on a version provided
[apiInstance deallocate3gppServiceWith:body
    version:version
              completionHandler: ^(3gppServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.Onap3gppServiceInstancesApi()

var body = ; // {DeAllocate3gppService} 

var version = version_example; // {String} 


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

namespace Example
{
    public class deallocate3gppServiceExample
    {
        public void main()
        {
            
            var apiInstance = new Onap3gppServiceInstancesApi();
            var body = new DeAllocate3gppService(); // DeAllocate3gppService | 
            var version = version_example;  // String | 

            try
            {
                // Terminate/Deallocate a 3GPP Service Instance on a version provided
                3gppServiceResponse result = apiInstance.deallocate3gppService(body, version);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Onap3gppServiceInstancesApi.deallocate3gppService: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\Onap3gppServiceInstancesApi();
$body = ; // DeAllocate3gppService | 
$version = version_example; // String | 

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

my $api_instance = WWW::SwaggerClient::Onap3gppServiceInstancesApi->new();
my $body = WWW::SwaggerClient::Object::DeAllocate3gppService->new(); # DeAllocate3gppService | 
my $version = version_example; # String | 

eval { 
    my $result = $api_instance->deallocate3gppService(body => $body, version => $version);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Onap3gppServiceInstancesApi->deallocate3gppService: $@\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.Onap3gppServiceInstancesApi()
body =  # DeAllocate3gppService | 
version = version_example # String | 

try: 
    # Terminate/Deallocate a 3GPP Service Instance on a version provided
    api_response = api_instance.deallocate3gpp_service(body, version)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Onap3gppServiceInstancesApi->deallocate3gppService: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
Body parameters
Name Description
body *

Responses

Status: default - successful operation


modify3gppService

Modify a 3GPP Service Instance on a version provided


/onap/so/infra/3gppservices/{version}/modify

Usage and SDK Samples

curl -X PUT "http://localhost/onap/so/infra/3gppservices/{version}/modify"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Onap3gppServiceInstancesApi;

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

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        Modify3gppService body = ; // Modify3gppService | 
        String version = version_example; // String | 
        try {
            3gppServiceResponse result = apiInstance.modify3gppService(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#modify3gppService");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Onap3gppServiceInstancesApi;

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        Modify3gppService body = ; // Modify3gppService | 
        String version = version_example; // String | 
        try {
            3gppServiceResponse result = apiInstance.modify3gppService(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#modify3gppService");
            e.printStackTrace();
        }
    }
}
Modify3gppService *body = ; // 
String *version = version_example; // 

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

// Modify a 3GPP Service Instance on a version provided
[apiInstance modify3gppServiceWith:body
    version:version
              completionHandler: ^(3gppServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.Onap3gppServiceInstancesApi()

var body = ; // {Modify3gppService} 

var version = version_example; // {String} 


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

namespace Example
{
    public class modify3gppServiceExample
    {
        public void main()
        {
            
            var apiInstance = new Onap3gppServiceInstancesApi();
            var body = new Modify3gppService(); // Modify3gppService | 
            var version = version_example;  // String | 

            try
            {
                // Modify a 3GPP Service Instance on a version provided
                3gppServiceResponse result = apiInstance.modify3gppService(body, version);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Onap3gppServiceInstancesApi.modify3gppService: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\Onap3gppServiceInstancesApi();
$body = ; // Modify3gppService | 
$version = version_example; // String | 

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

my $api_instance = WWW::SwaggerClient::Onap3gppServiceInstancesApi->new();
my $body = WWW::SwaggerClient::Object::Modify3gppService->new(); # Modify3gppService | 
my $version = version_example; # String | 

eval { 
    my $result = $api_instance->modify3gppService(body => $body, version => $version);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Onap3gppServiceInstancesApi->modify3gppService: $@\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.Onap3gppServiceInstancesApi()
body =  # Modify3gppService | 
version = version_example # String | 

try: 
    # Modify a 3GPP Service Instance on a version provided
    api_response = api_instance.modify3gpp_service(body, version)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Onap3gppServiceInstancesApi->modify3gppService: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
Body parameters
Name Description
body *

Responses

Status: default - successful operation


querySubnetCapability

Provides subnet capability based on subnet types


/onap/so/infra/3gppservices/{version}/subnetCapabilityQuery

Usage and SDK Samples

curl -X GET "http://localhost/onap/so/infra/3gppservices/{version}/subnetCapabilityQuery"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Onap3gppServiceInstancesApi;

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

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        QuerySubnetCapability body = ; // QuerySubnetCapability | 
        String version = version_example; // String | 
        try {
            Object result = apiInstance.querySubnetCapability(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#querySubnetCapability");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Onap3gppServiceInstancesApi;

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        QuerySubnetCapability body = ; // QuerySubnetCapability | 
        String version = version_example; // String | 
        try {
            Object result = apiInstance.querySubnetCapability(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#querySubnetCapability");
            e.printStackTrace();
        }
    }
}
QuerySubnetCapability *body = ; // 
String *version = version_example; // 

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

// Provides subnet capability based on subnet types
[apiInstance querySubnetCapabilityWith:body
    version:version
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.Onap3gppServiceInstancesApi()

var body = ; // {QuerySubnetCapability} 

var version = version_example; // {String} 


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

namespace Example
{
    public class querySubnetCapabilityExample
    {
        public void main()
        {
            
            var apiInstance = new Onap3gppServiceInstancesApi();
            var body = new QuerySubnetCapability(); // QuerySubnetCapability | 
            var version = version_example;  // String | 

            try
            {
                // Provides subnet capability based on subnet types
                Object result = apiInstance.querySubnetCapability(body, version);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Onap3gppServiceInstancesApi.querySubnetCapability: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\Onap3gppServiceInstancesApi();
$body = ; // QuerySubnetCapability | 
$version = version_example; // String | 

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

my $api_instance = WWW::SwaggerClient::Onap3gppServiceInstancesApi->new();
my $body = WWW::SwaggerClient::Object::QuerySubnetCapability->new(); # QuerySubnetCapability | 
my $version = version_example; # String | 

eval { 
    my $result = $api_instance->querySubnetCapability(body => $body, version => $version);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Onap3gppServiceInstancesApi->querySubnetCapability: $@\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.Onap3gppServiceInstancesApi()
body =  # QuerySubnetCapability | 
version = version_example # String | 

try: 
    # Provides subnet capability based on subnet types
    api_response = api_instance.query_subnet_capability(body, version)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Onap3gppServiceInstancesApi->querySubnetCapability: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
Body parameters
Name Description
body *

Responses

Status: default - successful operation with capabilities for the queried subnetTypes


OnapsoinfracloudResources

activateOperationEnvironment

Activate an Operational Environment


/onap/so/infra/cloudResources/{version}/operationalEnvironments/{operationalEnvironmentId}/activate

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/cloudResources/{version}/operationalEnvironments/{operationalEnvironmentId}/activate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfracloudResourcesApi;

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

public class OnapsoinfracloudResourcesApiExample {

    public static void main(String[] args) {
        
        OnapsoinfracloudResourcesApi apiInstance = new OnapsoinfracloudResourcesApi();
        String version = version_example; // String | 
        String operationalEnvironmentId = operationalEnvironmentId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.activateOperationEnvironment(version, operationalEnvironmentId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfracloudResourcesApi#activateOperationEnvironment");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfracloudResourcesApi;

public class OnapsoinfracloudResourcesApiExample {

    public static void main(String[] args) {
        OnapsoinfracloudResourcesApi apiInstance = new OnapsoinfracloudResourcesApi();
        String version = version_example; // String | 
        String operationalEnvironmentId = operationalEnvironmentId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.activateOperationEnvironment(version, operationalEnvironmentId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfracloudResourcesApi#activateOperationEnvironment");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *operationalEnvironmentId = operationalEnvironmentId_example; // 
String *body = body_example; //  (optional)

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

// Activate an Operational Environment
[apiInstance activateOperationEnvironmentWith:version
    operationalEnvironmentId:operationalEnvironmentId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfracloudResourcesApi()

var version = version_example; // {String} 

var operationalEnvironmentId = operationalEnvironmentId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.activateOperationEnvironment(version, operationalEnvironmentId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activateOperationEnvironmentExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfracloudResourcesApi();
            var version = version_example;  // String | 
            var operationalEnvironmentId = operationalEnvironmentId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Activate an Operational Environment
                apiInstance.activateOperationEnvironment(version, operationalEnvironmentId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfracloudResourcesApi.activateOperationEnvironment: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfracloudResourcesApi();
$version = version_example; // String | 
$operationalEnvironmentId = operationalEnvironmentId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->activateOperationEnvironment($version, $operationalEnvironmentId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfracloudResourcesApi->activateOperationEnvironment: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfracloudResourcesApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfracloudResourcesApi->new();
my $version = version_example; # String | 
my $operationalEnvironmentId = operationalEnvironmentId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->activateOperationEnvironment(version => $version, operationalEnvironmentId => $operationalEnvironmentId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfracloudResourcesApi->activateOperationEnvironment: $@\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.OnapsoinfracloudResourcesApi()
version = version_example # String | 
operationalEnvironmentId = operationalEnvironmentId_example # String | 
body = body_example # String |  (optional)

try: 
    # Activate an Operational Environment
    api_instance.activate_operation_environment(version, operationalEnvironmentId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfracloudResourcesApi->activateOperationEnvironment: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
operationalEnvironmentId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


createOperationEnvironment

Create an Operational Environment


/onap/so/infra/cloudResources/{version}/operationalEnvironments

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/cloudResources/{version}/operationalEnvironments"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfracloudResourcesApi;

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

public class OnapsoinfracloudResourcesApiExample {

    public static void main(String[] args) {
        
        OnapsoinfracloudResourcesApi apiInstance = new OnapsoinfracloudResourcesApi();
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createOperationEnvironment(version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfracloudResourcesApi#createOperationEnvironment");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfracloudResourcesApi;

public class OnapsoinfracloudResourcesApiExample {

    public static void main(String[] args) {
        OnapsoinfracloudResourcesApi apiInstance = new OnapsoinfracloudResourcesApi();
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createOperationEnvironment(version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfracloudResourcesApi#createOperationEnvironment");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *body = body_example; //  (optional)

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

// Create an Operational Environment
[apiInstance createOperationEnvironmentWith:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfracloudResourcesApi()

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createOperationEnvironment(version, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createOperationEnvironmentExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfracloudResourcesApi();
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Create an Operational Environment
                apiInstance.createOperationEnvironment(version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfracloudResourcesApi.createOperationEnvironment: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfracloudResourcesApi();
$version = version_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->createOperationEnvironment($version, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfracloudResourcesApi->createOperationEnvironment: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfracloudResourcesApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfracloudResourcesApi->new();
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->createOperationEnvironment(version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfracloudResourcesApi->createOperationEnvironment: $@\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.OnapsoinfracloudResourcesApi()
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # Create an Operational Environment
    api_instance.create_operation_environment(version, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfracloudResourcesApi->createOperationEnvironment: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


deactivateOperationEnvironment

Deactivate an Operational Environment


/onap/so/infra/cloudResources/{version}/operationalEnvironments/{operationalEnvironmentId}/deactivate

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/cloudResources/{version}/operationalEnvironments/{operationalEnvironmentId}/deactivate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfracloudResourcesApi;

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

public class OnapsoinfracloudResourcesApiExample {

    public static void main(String[] args) {
        
        OnapsoinfracloudResourcesApi apiInstance = new OnapsoinfracloudResourcesApi();
        String version = version_example; // String | 
        String operationalEnvironmentId = operationalEnvironmentId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deactivateOperationEnvironment(version, operationalEnvironmentId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfracloudResourcesApi#deactivateOperationEnvironment");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfracloudResourcesApi;

public class OnapsoinfracloudResourcesApiExample {

    public static void main(String[] args) {
        OnapsoinfracloudResourcesApi apiInstance = new OnapsoinfracloudResourcesApi();
        String version = version_example; // String | 
        String operationalEnvironmentId = operationalEnvironmentId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deactivateOperationEnvironment(version, operationalEnvironmentId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfracloudResourcesApi#deactivateOperationEnvironment");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *operationalEnvironmentId = operationalEnvironmentId_example; // 
String *body = body_example; //  (optional)

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

// Deactivate an Operational Environment
[apiInstance deactivateOperationEnvironmentWith:version
    operationalEnvironmentId:operationalEnvironmentId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfracloudResourcesApi()

var version = version_example; // {String} 

var operationalEnvironmentId = operationalEnvironmentId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deactivateOperationEnvironment(version, operationalEnvironmentId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deactivateOperationEnvironmentExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfracloudResourcesApi();
            var version = version_example;  // String | 
            var operationalEnvironmentId = operationalEnvironmentId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Deactivate an Operational Environment
                apiInstance.deactivateOperationEnvironment(version, operationalEnvironmentId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfracloudResourcesApi.deactivateOperationEnvironment: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfracloudResourcesApi();
$version = version_example; // String | 
$operationalEnvironmentId = operationalEnvironmentId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deactivateOperationEnvironment($version, $operationalEnvironmentId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfracloudResourcesApi->deactivateOperationEnvironment: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfracloudResourcesApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfracloudResourcesApi->new();
my $version = version_example; # String | 
my $operationalEnvironmentId = operationalEnvironmentId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deactivateOperationEnvironment(version => $version, operationalEnvironmentId => $operationalEnvironmentId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfracloudResourcesApi->deactivateOperationEnvironment: $@\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.OnapsoinfracloudResourcesApi()
version = version_example # String | 
operationalEnvironmentId = operationalEnvironmentId_example # String | 
body = body_example # String |  (optional)

try: 
    # Deactivate an Operational Environment
    api_instance.deactivate_operation_environment(version, operationalEnvironmentId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfracloudResourcesApi->deactivateOperationEnvironment: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
operationalEnvironmentId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


OnapsoinfracloudResourcesRequests

getOperationEnvironmentStatusFilter

Get status of an Operational Environment based on filter criteria


/onap/so/infra/cloudResourcesRequests/{version}

Usage and SDK Samples

curl -X GET "http://localhost/onap/so/infra/cloudResourcesRequests/{version}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfracloudResourcesRequestsApi;

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

public class OnapsoinfracloudResourcesRequestsApiExample {

    public static void main(String[] args) {
        
        OnapsoinfracloudResourcesRequestsApi apiInstance = new OnapsoinfracloudResourcesRequestsApi();
        String version = version_example; // String | 
        try {
            apiInstance.getOperationEnvironmentStatusFilter(version);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfracloudResourcesRequestsApi#getOperationEnvironmentStatusFilter");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfracloudResourcesRequestsApi;

public class OnapsoinfracloudResourcesRequestsApiExample {

    public static void main(String[] args) {
        OnapsoinfracloudResourcesRequestsApi apiInstance = new OnapsoinfracloudResourcesRequestsApi();
        String version = version_example; // String | 
        try {
            apiInstance.getOperationEnvironmentStatusFilter(version);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfracloudResourcesRequestsApi#getOperationEnvironmentStatusFilter");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 

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

// Get status of an Operational Environment based on filter criteria
[apiInstance getOperationEnvironmentStatusFilterWith:version
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfracloudResourcesRequestsApi()

var version = version_example; // {String} 


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

namespace Example
{
    public class getOperationEnvironmentStatusFilterExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfracloudResourcesRequestsApi();
            var version = version_example;  // String | 

            try
            {
                // Get status of an Operational Environment based on filter criteria
                apiInstance.getOperationEnvironmentStatusFilter(version);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfracloudResourcesRequestsApi.getOperationEnvironmentStatusFilter: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfracloudResourcesRequestsApi();
$version = version_example; // String | 

try {
    $api_instance->getOperationEnvironmentStatusFilter($version);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfracloudResourcesRequestsApi->getOperationEnvironmentStatusFilter: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfracloudResourcesRequestsApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfracloudResourcesRequestsApi->new();
my $version = version_example; # String | 

eval { 
    $api_instance->getOperationEnvironmentStatusFilter(version => $version);
};
if ($@) {
    warn "Exception when calling OnapsoinfracloudResourcesRequestsApi->getOperationEnvironmentStatusFilter: $@\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.OnapsoinfracloudResourcesRequestsApi()
version = version_example # String | 

try: 
    # Get status of an Operational Environment based on filter criteria
    api_instance.get_operation_environment_status_filter(version)
except ApiException as e:
    print("Exception when calling OnapsoinfracloudResourcesRequestsApi->getOperationEnvironmentStatusFilter: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required

Responses

Status: default - successful operation


unlockOrchestrationRequestForReqId

Unlock CloudOrchestration requests for a specified requestId


/onap/so/infra/cloudResourcesRequests/{version}/{requestId}/unlock

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/cloudResourcesRequests/{version}/{requestId}/unlock"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfracloudResourcesRequestsApi;

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

public class OnapsoinfracloudResourcesRequestsApiExample {

    public static void main(String[] args) {
        
        OnapsoinfracloudResourcesRequestsApi apiInstance = new OnapsoinfracloudResourcesRequestsApi();
        String requestId = requestId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.unlockOrchestrationRequestForReqId(requestId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfracloudResourcesRequestsApi#unlockOrchestrationRequestForReqId");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfracloudResourcesRequestsApi;

public class OnapsoinfracloudResourcesRequestsApiExample {

    public static void main(String[] args) {
        OnapsoinfracloudResourcesRequestsApi apiInstance = new OnapsoinfracloudResourcesRequestsApi();
        String requestId = requestId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.unlockOrchestrationRequestForReqId(requestId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfracloudResourcesRequestsApi#unlockOrchestrationRequestForReqId");
            e.printStackTrace();
        }
    }
}
String *requestId = requestId_example; // 
String *version = version_example; // 
String *body = body_example; //  (optional)

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

// Unlock CloudOrchestration requests for a specified requestId
[apiInstance unlockOrchestrationRequestForReqIdWith:requestId
    version:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfracloudResourcesRequestsApi()

var requestId = requestId_example; // {String} 

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.unlockOrchestrationRequestForReqId(requestId, version, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class unlockOrchestrationRequestForReqIdExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfracloudResourcesRequestsApi();
            var requestId = requestId_example;  // String | 
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Unlock CloudOrchestration requests for a specified requestId
                apiInstance.unlockOrchestrationRequestForReqId(requestId, version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfracloudResourcesRequestsApi.unlockOrchestrationRequestForReqId: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfracloudResourcesRequestsApi();
$requestId = requestId_example; // String | 
$version = version_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->unlockOrchestrationRequestForReqId($requestId, $version, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfracloudResourcesRequestsApi->unlockOrchestrationRequestForReqId: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfracloudResourcesRequestsApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfracloudResourcesRequestsApi->new();
my $requestId = requestId_example; # String | 
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->unlockOrchestrationRequestForReqId(requestId => $requestId, version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfracloudResourcesRequestsApi->unlockOrchestrationRequestForReqId: $@\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.OnapsoinfracloudResourcesRequestsApi()
requestId = requestId_example # String | 
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # Unlock CloudOrchestration requests for a specified requestId
    api_instance.unlock_orchestration_request_for_req_id(requestId, version, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfracloudResourcesRequestsApi->unlockOrchestrationRequestForReqId: %s\n" % e)

Parameters

Path parameters
Name Description
requestId*
String
Required
version*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


OnapsoinfrainstanceManagement

executeServiceLevelCustomWorkflow

Executing service level custom workflow


/onap/so/infra/instanceManagement/{version}/serviceInstances/{serviceInstanceId}/workflows/{workflow_UUID}

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/instanceManagement/{version}/serviceInstances/{serviceInstanceId}/workflows/{workflow_UUID}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfrainstanceManagementApi;

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

public class OnapsoinfrainstanceManagementApiExample {

    public static void main(String[] args) {
        
        OnapsoinfrainstanceManagementApi apiInstance = new OnapsoinfrainstanceManagementApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String workflowUUID = workflowUUID_example; // String | 
        ServiceLevelWorkflowExecution body = ; // ServiceLevelWorkflowExecution | 
        try {
            apiInstance.executeServiceLevelCustomWorkflow(version, serviceInstanceId, workflowUUID, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfrainstanceManagementApi#executeServiceLevelCustomWorkflow");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfrainstanceManagementApi;

public class OnapsoinfrainstanceManagementApiExample {

    public static void main(String[] args) {
        OnapsoinfrainstanceManagementApi apiInstance = new OnapsoinfrainstanceManagementApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String workflowUUID = workflowUUID_example; // String | 
        ServiceLevelWorkflowExecution body = ; // ServiceLevelWorkflowExecution | 
        try {
            apiInstance.executeServiceLevelCustomWorkflow(version, serviceInstanceId, workflowUUID, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfrainstanceManagementApi#executeServiceLevelCustomWorkflow");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *workflowUUID = workflowUUID_example; // 
ServiceLevelWorkflowExecution *body = ; //  (optional)

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

// Executing service level custom workflow
[apiInstance executeServiceLevelCustomWorkflowWith:version
    serviceInstanceId:serviceInstanceId
    workflowUUID:workflowUUID
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfrainstanceManagementApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var workflowUUID = workflowUUID_example; // {String} 

var opts = { 
  'body':  // {ServiceLevelWorkflowExecution} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.executeServiceLevelCustomWorkflow(version, serviceInstanceId, workflowUUID, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class executeServiceLevelCustomWorkflowExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfrainstanceManagementApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var workflowUUID = workflowUUID_example;  // String | 
            var body = new ServiceLevelWorkflowExecution(); // ServiceLevelWorkflowExecution |  (optional) 

            try
            {
                // Executing service level custom workflow
                apiInstance.executeServiceLevelCustomWorkflow(version, serviceInstanceId, workflowUUID, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfrainstanceManagementApi.executeServiceLevelCustomWorkflow: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfrainstanceManagementApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$workflowUUID = workflowUUID_example; // String | 
$body = ; // ServiceLevelWorkflowExecution | 

try {
    $api_instance->executeServiceLevelCustomWorkflow($version, $serviceInstanceId, $workflowUUID, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfrainstanceManagementApi->executeServiceLevelCustomWorkflow: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfrainstanceManagementApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfrainstanceManagementApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $workflowUUID = workflowUUID_example; # String | 
my $body = WWW::SwaggerClient::Object::ServiceLevelWorkflowExecution->new(); # ServiceLevelWorkflowExecution | 

eval { 
    $api_instance->executeServiceLevelCustomWorkflow(version => $version, serviceInstanceId => $serviceInstanceId, workflowUUID => $workflowUUID, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfrainstanceManagementApi->executeServiceLevelCustomWorkflow: $@\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.OnapsoinfrainstanceManagementApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
workflowUUID = workflowUUID_example # String | 
body =  # ServiceLevelWorkflowExecution |  (optional)

try: 
    # Executing service level custom workflow
    api_instance.execute_service_level_custom_workflow(version, serviceInstanceId, workflowUUID, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfrainstanceManagementApi->executeServiceLevelCustomWorkflow: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
workflow_UUID*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


OnapsoinframodelDistributions

updateModelDistributionStatus

Update model distribution status


/onap/so/infra/modelDistributions/{version}/distributions/{distributionId}

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/modelDistributions/{version}/distributions/{distributionId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinframodelDistributionsApi;

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

public class OnapsoinframodelDistributionsApiExample {

    public static void main(String[] args) {
        
        OnapsoinframodelDistributionsApi apiInstance = new OnapsoinframodelDistributionsApi();
        String version = version_example; // String | 
        String distributionId = distributionId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateModelDistributionStatus(version, distributionId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinframodelDistributionsApi#updateModelDistributionStatus");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinframodelDistributionsApi;

public class OnapsoinframodelDistributionsApiExample {

    public static void main(String[] args) {
        OnapsoinframodelDistributionsApi apiInstance = new OnapsoinframodelDistributionsApi();
        String version = version_example; // String | 
        String distributionId = distributionId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateModelDistributionStatus(version, distributionId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinframodelDistributionsApi#updateModelDistributionStatus");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *distributionId = distributionId_example; // 
String *body = body_example; //  (optional)

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

// Update model distribution status
[apiInstance updateModelDistributionStatusWith:version
    distributionId:distributionId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinframodelDistributionsApi()

var version = version_example; // {String} 

var distributionId = distributionId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateModelDistributionStatus(version, distributionId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class updateModelDistributionStatusExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinframodelDistributionsApi();
            var version = version_example;  // String | 
            var distributionId = distributionId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Update model distribution status
                apiInstance.updateModelDistributionStatus(version, distributionId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinframodelDistributionsApi.updateModelDistributionStatus: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinframodelDistributionsApi();
$version = version_example; // String | 
$distributionId = distributionId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->updateModelDistributionStatus($version, $distributionId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinframodelDistributionsApi->updateModelDistributionStatus: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinframodelDistributionsApi;

my $api_instance = WWW::SwaggerClient::OnapsoinframodelDistributionsApi->new();
my $version = version_example; # String | 
my $distributionId = distributionId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->updateModelDistributionStatus(version => $version, distributionId => $distributionId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinframodelDistributionsApi->updateModelDistributionStatus: $@\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.OnapsoinframodelDistributionsApi()
version = version_example # String | 
distributionId = distributionId_example # String | 
body = body_example # String |  (optional)

try: 
    # Update model distribution status
    api_instance.update_model_distribution_status(version, distributionId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinframodelDistributionsApi->updateModelDistributionStatus: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
distributionId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


OnapsoinfraorchestrationRequests

getOrchestrationRequest

Find Orchestrated Requests for a URI Information


/onap/so/infra/orchestrationRequests/{version}

Usage and SDK Samples

curl -X GET "http://localhost/onap/so/infra/orchestrationRequests/{version}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraorchestrationRequestsApi;

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

public class OnapsoinfraorchestrationRequestsApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraorchestrationRequestsApi apiInstance = new OnapsoinfraorchestrationRequestsApi();
        String version = version_example; // String | 
        try {
            apiInstance.getOrchestrationRequest(version);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationRequestsApi#getOrchestrationRequest");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraorchestrationRequestsApi;

public class OnapsoinfraorchestrationRequestsApiExample {

    public static void main(String[] args) {
        OnapsoinfraorchestrationRequestsApi apiInstance = new OnapsoinfraorchestrationRequestsApi();
        String version = version_example; // String | 
        try {
            apiInstance.getOrchestrationRequest(version);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationRequestsApi#getOrchestrationRequest");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 

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

// Find Orchestrated Requests for a URI Information
[apiInstance getOrchestrationRequestWith:version
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraorchestrationRequestsApi()

var version = version_example; // {String} 


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

namespace Example
{
    public class getOrchestrationRequestExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraorchestrationRequestsApi();
            var version = version_example;  // String | 

            try
            {
                // Find Orchestrated Requests for a URI Information
                apiInstance.getOrchestrationRequest(version);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraorchestrationRequestsApi.getOrchestrationRequest: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraorchestrationRequestsApi();
$version = version_example; // String | 

try {
    $api_instance->getOrchestrationRequest($version);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraorchestrationRequestsApi->getOrchestrationRequest: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraorchestrationRequestsApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraorchestrationRequestsApi->new();
my $version = version_example; # String | 

eval { 
    $api_instance->getOrchestrationRequest(version => $version);
};
if ($@) {
    warn "Exception when calling OnapsoinfraorchestrationRequestsApi->getOrchestrationRequest: $@\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.OnapsoinfraorchestrationRequestsApi()
version = version_example # String | 

try: 
    # Find Orchestrated Requests for a URI Information
    api_instance.get_orchestration_request(version)
except ApiException as e:
    print("Exception when calling OnapsoinfraorchestrationRequestsApi->getOrchestrationRequest: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required

Responses

Status: default - successful operation


getOrchestrationRequestForReqId

Find Orchestrated Requests for a given requestId


/onap/so/infra/orchestrationRequests/{version}/{requestId}

Usage and SDK Samples

curl -X GET "http://localhost/onap/so/infra/orchestrationRequests/{version}/{requestId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraorchestrationRequestsApi;

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

public class OnapsoinfraorchestrationRequestsApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraorchestrationRequestsApi apiInstance = new OnapsoinfraorchestrationRequestsApi();
        String requestId = requestId_example; // String | 
        String version = version_example; // String | 
        try {
            apiInstance.getOrchestrationRequestForReqId(requestId, version);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationRequestsApi#getOrchestrationRequestForReqId");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraorchestrationRequestsApi;

public class OnapsoinfraorchestrationRequestsApiExample {

    public static void main(String[] args) {
        OnapsoinfraorchestrationRequestsApi apiInstance = new OnapsoinfraorchestrationRequestsApi();
        String requestId = requestId_example; // String | 
        String version = version_example; // String | 
        try {
            apiInstance.getOrchestrationRequestForReqId(requestId, version);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationRequestsApi#getOrchestrationRequestForReqId");
            e.printStackTrace();
        }
    }
}
String *requestId = requestId_example; // 
String *version = version_example; // 

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

// Find Orchestrated Requests for a given requestId
[apiInstance getOrchestrationRequestForReqIdWith:requestId
    version:version
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraorchestrationRequestsApi()

var requestId = requestId_example; // {String} 

var version = version_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getOrchestrationRequestForReqId(requestId, version, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getOrchestrationRequestForReqIdExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraorchestrationRequestsApi();
            var requestId = requestId_example;  // String | 
            var version = version_example;  // String | 

            try
            {
                // Find Orchestrated Requests for a given requestId
                apiInstance.getOrchestrationRequestForReqId(requestId, version);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraorchestrationRequestsApi.getOrchestrationRequestForReqId: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraorchestrationRequestsApi();
$requestId = requestId_example; // String | 
$version = version_example; // String | 

try {
    $api_instance->getOrchestrationRequestForReqId($requestId, $version);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraorchestrationRequestsApi->getOrchestrationRequestForReqId: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraorchestrationRequestsApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraorchestrationRequestsApi->new();
my $requestId = requestId_example; # String | 
my $version = version_example; # String | 

eval { 
    $api_instance->getOrchestrationRequestForReqId(requestId => $requestId, version => $version);
};
if ($@) {
    warn "Exception when calling OnapsoinfraorchestrationRequestsApi->getOrchestrationRequestForReqId: $@\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.OnapsoinfraorchestrationRequestsApi()
requestId = requestId_example # String | 
version = version_example # String | 

try: 
    # Find Orchestrated Requests for a given requestId
    api_instance.get_orchestration_request_for_req_id(requestId, version)
except ApiException as e:
    print("Exception when calling OnapsoinfraorchestrationRequestsApi->getOrchestrationRequestForReqId: %s\n" % e)

Parameters

Path parameters
Name Description
requestId*
String
Required
version*
String
Required

Responses

Status: default - successful operation


unlockOrchestrationRequest

Unlock Orchestrated Requests for a given requestId


/onap/so/infra/orchestrationRequests/{version}/{requestId}/unlock

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/orchestrationRequests/{version}/{requestId}/unlock"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraorchestrationRequestsApi;

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

public class OnapsoinfraorchestrationRequestsApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraorchestrationRequestsApi apiInstance = new OnapsoinfraorchestrationRequestsApi();
        String requestId = requestId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.unlockOrchestrationRequest(requestId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationRequestsApi#unlockOrchestrationRequest");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraorchestrationRequestsApi;

public class OnapsoinfraorchestrationRequestsApiExample {

    public static void main(String[] args) {
        OnapsoinfraorchestrationRequestsApi apiInstance = new OnapsoinfraorchestrationRequestsApi();
        String requestId = requestId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.unlockOrchestrationRequest(requestId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationRequestsApi#unlockOrchestrationRequest");
            e.printStackTrace();
        }
    }
}
String *requestId = requestId_example; // 
String *version = version_example; // 
String *body = body_example; //  (optional)

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

// Unlock Orchestrated Requests for a given requestId
[apiInstance unlockOrchestrationRequestWith:requestId
    version:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraorchestrationRequestsApi()

var requestId = requestId_example; // {String} 

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.unlockOrchestrationRequest(requestId, version, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class unlockOrchestrationRequestExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraorchestrationRequestsApi();
            var requestId = requestId_example;  // String | 
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Unlock Orchestrated Requests for a given requestId
                apiInstance.unlockOrchestrationRequest(requestId, version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraorchestrationRequestsApi.unlockOrchestrationRequest: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraorchestrationRequestsApi();
$requestId = requestId_example; // String | 
$version = version_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->unlockOrchestrationRequest($requestId, $version, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraorchestrationRequestsApi->unlockOrchestrationRequest: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraorchestrationRequestsApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraorchestrationRequestsApi->new();
my $requestId = requestId_example; # String | 
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->unlockOrchestrationRequest(requestId => $requestId, version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraorchestrationRequestsApi->unlockOrchestrationRequest: $@\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.OnapsoinfraorchestrationRequestsApi()
requestId = requestId_example # String | 
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # Unlock Orchestrated Requests for a given requestId
    api_instance.unlock_orchestration_request(requestId, version, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraorchestrationRequestsApi->unlockOrchestrationRequest: %s\n" % e)

Parameters

Path parameters
Name Description
requestId*
String
Required
version*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


OnapsoinfraorchestrationTasks

abortOrchestrationTask

abort orchestrationTask for a given taskId


/onap/so/infra/orchestrationTasks/{version}/{taskId}/abort

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/orchestrationTasks/{version}/{taskId}/abort"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

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

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String taskId = taskId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.abortOrchestrationTask(taskId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#abortOrchestrationTask");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String taskId = taskId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.abortOrchestrationTask(taskId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#abortOrchestrationTask");
            e.printStackTrace();
        }
    }
}
String *taskId = taskId_example; // 
String *version = version_example; // 
String *body = body_example; //  (optional)

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

// abort orchestrationTask for a given taskId
[apiInstance abortOrchestrationTaskWith:taskId
    version:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraorchestrationTasksApi()

var taskId = taskId_example; // {String} 

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.abortOrchestrationTask(taskId, version, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class abortOrchestrationTaskExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraorchestrationTasksApi();
            var taskId = taskId_example;  // String | 
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // abort orchestrationTask for a given taskId
                apiInstance.abortOrchestrationTask(taskId, version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraorchestrationTasksApi.abortOrchestrationTask: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraorchestrationTasksApi();
$taskId = taskId_example; // String | 
$version = version_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->abortOrchestrationTask($taskId, $version, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraorchestrationTasksApi->abortOrchestrationTask: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi->new();
my $taskId = taskId_example; # String | 
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->abortOrchestrationTask(taskId => $taskId, version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraorchestrationTasksApi->abortOrchestrationTask: $@\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.OnapsoinfraorchestrationTasksApi()
taskId = taskId_example # String | 
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # abort orchestrationTask for a given taskId
    api_instance.abort_orchestration_task(taskId, version, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraorchestrationTasksApi->abortOrchestrationTask: %s\n" % e)

Parameters

Path parameters
Name Description
taskId*
String
Required
version*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


commitOrchestrationTask

commit orchestrationTask for a given taskId


/onap/so/infra/orchestrationTasks/{version}/{taskId}/commit

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/orchestrationTasks/{version}/{taskId}/commit"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

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

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String taskId = taskId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.commitOrchestrationTask(taskId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#commitOrchestrationTask");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String taskId = taskId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.commitOrchestrationTask(taskId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#commitOrchestrationTask");
            e.printStackTrace();
        }
    }
}
String *taskId = taskId_example; // 
String *version = version_example; // 
String *body = body_example; //  (optional)

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

// commit orchestrationTask for a given taskId
[apiInstance commitOrchestrationTaskWith:taskId
    version:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraorchestrationTasksApi()

var taskId = taskId_example; // {String} 

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.commitOrchestrationTask(taskId, version, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class commitOrchestrationTaskExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraorchestrationTasksApi();
            var taskId = taskId_example;  // String | 
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // commit orchestrationTask for a given taskId
                apiInstance.commitOrchestrationTask(taskId, version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraorchestrationTasksApi.commitOrchestrationTask: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraorchestrationTasksApi();
$taskId = taskId_example; // String | 
$version = version_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->commitOrchestrationTask($taskId, $version, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraorchestrationTasksApi->commitOrchestrationTask: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi->new();
my $taskId = taskId_example; # String | 
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->commitOrchestrationTask(taskId => $taskId, version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraorchestrationTasksApi->commitOrchestrationTask: $@\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.OnapsoinfraorchestrationTasksApi()
taskId = taskId_example # String | 
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # commit orchestrationTask for a given taskId
    api_instance.commit_orchestration_task(taskId, version, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraorchestrationTasksApi->commitOrchestrationTask: %s\n" % e)

Parameters

Path parameters
Name Description
taskId*
String
Required
version*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


createOrchestrationTask

Create an orchestrationTask


/onap/so/infra/orchestrationTasks/{version}

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/orchestrationTasks/{version}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

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

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createOrchestrationTask(version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#createOrchestrationTask");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createOrchestrationTask(version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#createOrchestrationTask");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *body = body_example; //  (optional)

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

// Create an orchestrationTask
[apiInstance createOrchestrationTaskWith:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraorchestrationTasksApi()

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createOrchestrationTask(version, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createOrchestrationTaskExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraorchestrationTasksApi();
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Create an orchestrationTask
                apiInstance.createOrchestrationTask(version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraorchestrationTasksApi.createOrchestrationTask: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraorchestrationTasksApi();
$version = version_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->createOrchestrationTask($version, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraorchestrationTasksApi->createOrchestrationTask: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi->new();
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->createOrchestrationTask(version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraorchestrationTasksApi->createOrchestrationTask: $@\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.OnapsoinfraorchestrationTasksApi()
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # Create an orchestrationTask
    api_instance.create_orchestration_task(version, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraorchestrationTasksApi->createOrchestrationTask: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


deleteOrchestrationTask

delete orchestrationTask for a given taskId


/onap/so/infra/orchestrationTasks/{version}/{taskId}

Usage and SDK Samples

curl -X DELETE "http://localhost/onap/so/infra/orchestrationTasks/{version}/{taskId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

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

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String taskId = taskId_example; // String | 
        String version = version_example; // String | 
        try {
            apiInstance.deleteOrchestrationTask(taskId, version);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#deleteOrchestrationTask");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String taskId = taskId_example; // String | 
        String version = version_example; // String | 
        try {
            apiInstance.deleteOrchestrationTask(taskId, version);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#deleteOrchestrationTask");
            e.printStackTrace();
        }
    }
}
String *taskId = taskId_example; // 
String *version = version_example; // 

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

// delete orchestrationTask for a given taskId
[apiInstance deleteOrchestrationTaskWith:taskId
    version:version
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraorchestrationTasksApi()

var taskId = taskId_example; // {String} 

var version = version_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteOrchestrationTask(taskId, version, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteOrchestrationTaskExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraorchestrationTasksApi();
            var taskId = taskId_example;  // String | 
            var version = version_example;  // String | 

            try
            {
                // delete orchestrationTask for a given taskId
                apiInstance.deleteOrchestrationTask(taskId, version);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraorchestrationTasksApi.deleteOrchestrationTask: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraorchestrationTasksApi();
$taskId = taskId_example; // String | 
$version = version_example; // String | 

try {
    $api_instance->deleteOrchestrationTask($taskId, $version);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraorchestrationTasksApi->deleteOrchestrationTask: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi->new();
my $taskId = taskId_example; # String | 
my $version = version_example; # String | 

eval { 
    $api_instance->deleteOrchestrationTask(taskId => $taskId, version => $version);
};
if ($@) {
    warn "Exception when calling OnapsoinfraorchestrationTasksApi->deleteOrchestrationTask: $@\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.OnapsoinfraorchestrationTasksApi()
taskId = taskId_example # String | 
version = version_example # String | 

try: 
    # delete orchestrationTask for a given taskId
    api_instance.delete_orchestration_task(taskId, version)
except ApiException as e:
    print("Exception when calling OnapsoinfraorchestrationTasksApi->deleteOrchestrationTask: %s\n" % e)

Parameters

Path parameters
Name Description
taskId*
String
Required
version*
String
Required

Responses

Status: default - successful operation


getAllOrchestrationTasks

Get all orchestrationTasks


/onap/so/infra/orchestrationTasks/{version}

Usage and SDK Samples

curl -X GET "http://localhost/onap/so/infra/orchestrationTasks/{version}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

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

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String version = version_example; // String | 
        try {
            apiInstance.getAllOrchestrationTasks(version);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#getAllOrchestrationTasks");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String version = version_example; // String | 
        try {
            apiInstance.getAllOrchestrationTasks(version);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#getAllOrchestrationTasks");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 

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

// Get all orchestrationTasks
[apiInstance getAllOrchestrationTasksWith:version
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraorchestrationTasksApi()

var version = version_example; // {String} 


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

namespace Example
{
    public class getAllOrchestrationTasksExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraorchestrationTasksApi();
            var version = version_example;  // String | 

            try
            {
                // Get all orchestrationTasks
                apiInstance.getAllOrchestrationTasks(version);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraorchestrationTasksApi.getAllOrchestrationTasks: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraorchestrationTasksApi();
$version = version_example; // String | 

try {
    $api_instance->getAllOrchestrationTasks($version);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraorchestrationTasksApi->getAllOrchestrationTasks: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi->new();
my $version = version_example; # String | 

eval { 
    $api_instance->getAllOrchestrationTasks(version => $version);
};
if ($@) {
    warn "Exception when calling OnapsoinfraorchestrationTasksApi->getAllOrchestrationTasks: $@\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.OnapsoinfraorchestrationTasksApi()
version = version_example # String | 

try: 
    # Get all orchestrationTasks
    api_instance.get_all_orchestration_tasks(version)
except ApiException as e:
    print("Exception when calling OnapsoinfraorchestrationTasksApi->getAllOrchestrationTasks: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required

Responses

Status: default - successful operation


getOrchestrationTask

Get orchestrationTask for a given taskId


/onap/so/infra/orchestrationTasks/{version}/{taskId}

Usage and SDK Samples

curl -X GET "http://localhost/onap/so/infra/orchestrationTasks/{version}/{taskId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

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

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String taskId = taskId_example; // String | 
        String version = version_example; // String | 
        try {
            apiInstance.getOrchestrationTask(taskId, version);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#getOrchestrationTask");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String taskId = taskId_example; // String | 
        String version = version_example; // String | 
        try {
            apiInstance.getOrchestrationTask(taskId, version);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#getOrchestrationTask");
            e.printStackTrace();
        }
    }
}
String *taskId = taskId_example; // 
String *version = version_example; // 

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

// Get orchestrationTask for a given taskId
[apiInstance getOrchestrationTaskWith:taskId
    version:version
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraorchestrationTasksApi()

var taskId = taskId_example; // {String} 

var version = version_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getOrchestrationTask(taskId, version, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getOrchestrationTaskExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraorchestrationTasksApi();
            var taskId = taskId_example;  // String | 
            var version = version_example;  // String | 

            try
            {
                // Get orchestrationTask for a given taskId
                apiInstance.getOrchestrationTask(taskId, version);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraorchestrationTasksApi.getOrchestrationTask: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraorchestrationTasksApi();
$taskId = taskId_example; // String | 
$version = version_example; // String | 

try {
    $api_instance->getOrchestrationTask($taskId, $version);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraorchestrationTasksApi->getOrchestrationTask: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi->new();
my $taskId = taskId_example; # String | 
my $version = version_example; # String | 

eval { 
    $api_instance->getOrchestrationTask(taskId => $taskId, version => $version);
};
if ($@) {
    warn "Exception when calling OnapsoinfraorchestrationTasksApi->getOrchestrationTask: $@\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.OnapsoinfraorchestrationTasksApi()
taskId = taskId_example # String | 
version = version_example # String | 

try: 
    # Get orchestrationTask for a given taskId
    api_instance.get_orchestration_task(taskId, version)
except ApiException as e:
    print("Exception when calling OnapsoinfraorchestrationTasksApi->getOrchestrationTask: %s\n" % e)

Parameters

Path parameters
Name Description
taskId*
String
Required
version*
String
Required

Responses

Status: default - successful operation


updateOrchestrationTask

update orchestrationTask for a given taskId


/onap/so/infra/orchestrationTasks/{version}/{taskId}

Usage and SDK Samples

curl -X PUT "http://localhost/onap/so/infra/orchestrationTasks/{version}/{taskId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

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

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String taskId = taskId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateOrchestrationTask(taskId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#updateOrchestrationTask");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String taskId = taskId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateOrchestrationTask(taskId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#updateOrchestrationTask");
            e.printStackTrace();
        }
    }
}
String *taskId = taskId_example; // 
String *version = version_example; // 
String *body = body_example; //  (optional)

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

// update orchestrationTask for a given taskId
[apiInstance updateOrchestrationTaskWith:taskId
    version:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraorchestrationTasksApi()

var taskId = taskId_example; // {String} 

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateOrchestrationTask(taskId, version, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class updateOrchestrationTaskExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraorchestrationTasksApi();
            var taskId = taskId_example;  // String | 
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // update orchestrationTask for a given taskId
                apiInstance.updateOrchestrationTask(taskId, version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraorchestrationTasksApi.updateOrchestrationTask: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraorchestrationTasksApi();
$taskId = taskId_example; // String | 
$version = version_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->updateOrchestrationTask($taskId, $version, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraorchestrationTasksApi->updateOrchestrationTask: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi->new();
my $taskId = taskId_example; # String | 
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->updateOrchestrationTask(taskId => $taskId, version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraorchestrationTasksApi->updateOrchestrationTask: $@\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.OnapsoinfraorchestrationTasksApi()
taskId = taskId_example # String | 
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # update orchestrationTask for a given taskId
    api_instance.update_orchestration_task(taskId, version, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraorchestrationTasksApi->updateOrchestrationTask: %s\n" % e)

Parameters

Path parameters
Name Description
taskId*
String
Required
version*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


OnapsoinfraserviceInstantiation

activatePort

Activate Port Mirroring


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/configurations/{configurationInstanceId}/activate

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/configurations/{configurationInstanceId}/activate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String configurationInstanceId = configurationInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.activatePort(version, serviceInstanceId, configurationInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#activatePort");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String configurationInstanceId = configurationInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.activatePort(version, serviceInstanceId, configurationInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#activatePort");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *configurationInstanceId = configurationInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Activate Port Mirroring
[apiInstance activatePortWith:version
    serviceInstanceId:serviceInstanceId
    configurationInstanceId:configurationInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var configurationInstanceId = configurationInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.activatePort(version, serviceInstanceId, configurationInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activatePortExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var configurationInstanceId = configurationInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Activate Port Mirroring
                apiInstance.activatePort(version, serviceInstanceId, configurationInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.activatePort: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$configurationInstanceId = configurationInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->activatePort($version, $serviceInstanceId, $configurationInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->activatePort: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $configurationInstanceId = configurationInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->activatePort(version => $version, serviceInstanceId => $serviceInstanceId, configurationInstanceId => $configurationInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->activatePort: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
configurationInstanceId = configurationInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Activate Port Mirroring
    api_instance.activate_port(version, serviceInstanceId, configurationInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->activatePort: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
configurationInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


activateServiceInstance

Activate provided Service Instance


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/activate

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/activate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.activateServiceInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#activateServiceInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.activateServiceInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#activateServiceInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Activate provided Service Instance
[apiInstance activateServiceInstanceWith:version
    serviceInstanceId:serviceInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.activateServiceInstance(version, serviceInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activateServiceInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Activate provided Service Instance
                apiInstance.activateServiceInstance(version, serviceInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.activateServiceInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->activateServiceInstance($version, $serviceInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->activateServiceInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->activateServiceInstance(version => $version, serviceInstanceId => $serviceInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->activateServiceInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Activate provided Service Instance
    api_instance.activate_service_instance(version, serviceInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->activateServiceInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


addRelationships

Add Relationships to a Service Instance


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/addRelationships

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/addRelationships"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.addRelationships(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#addRelationships");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.addRelationships(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#addRelationships");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Add Relationships to a Service Instance
[apiInstance addRelationshipsWith:version
    serviceInstanceId:serviceInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.addRelationships(version, serviceInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addRelationshipsExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Add Relationships to a Service Instance
                apiInstance.addRelationships(version, serviceInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.addRelationships: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->addRelationships($version, $serviceInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->addRelationships: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->addRelationships(version => $version, serviceInstanceId => $serviceInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->addRelationships: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Add Relationships to a Service Instance
    api_instance.add_relationships(version, serviceInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->addRelationships: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


applyUpdatedConfig

Apply updated configuration


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/applyUpdatedConfig

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/applyUpdatedConfig"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.applyUpdatedConfig(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#applyUpdatedConfig");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.applyUpdatedConfig(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#applyUpdatedConfig");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Apply updated configuration
[apiInstance applyUpdatedConfigWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.applyUpdatedConfig(version, serviceInstanceId, vnfInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class applyUpdatedConfigExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Apply updated configuration
                apiInstance.applyUpdatedConfig(version, serviceInstanceId, vnfInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.applyUpdatedConfig: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->applyUpdatedConfig($version, $serviceInstanceId, $vnfInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->applyUpdatedConfig: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->applyUpdatedConfig(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->applyUpdatedConfig: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Apply updated configuration
    api_instance.apply_updated_config(version, serviceInstanceId, vnfInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->applyUpdatedConfig: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
vnfInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


assignServiceInstance

Assign Service Instance


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/assign

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/assign"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.assignServiceInstance(version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#assignServiceInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.assignServiceInstance(version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#assignServiceInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *body = body_example; //  (optional)

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

// Assign Service Instance
[apiInstance assignServiceInstanceWith:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.assignServiceInstance(version, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class assignServiceInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Assign Service Instance
                apiInstance.assignServiceInstance(version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.assignServiceInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->assignServiceInstance($version, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->assignServiceInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->assignServiceInstance(version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->assignServiceInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # Assign Service Instance
    api_instance.assign_service_instance(version, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->assignServiceInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


createNetworkInstance

Create NetworkInstance on a specified version and serviceInstance


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/networks

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/networks"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createNetworkInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createNetworkInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createNetworkInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createNetworkInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Create NetworkInstance on a specified version and serviceInstance 
[apiInstance createNetworkInstanceWith:version
    serviceInstanceId:serviceInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createNetworkInstance(version, serviceInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createNetworkInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Create NetworkInstance on a specified version and serviceInstance 
                apiInstance.createNetworkInstance(version, serviceInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.createNetworkInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->createNetworkInstance($version, $serviceInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->createNetworkInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->createNetworkInstance(version => $version, serviceInstanceId => $serviceInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->createNetworkInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Create NetworkInstance on a specified version and serviceInstance 
    api_instance.create_network_instance(version, serviceInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->createNetworkInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


createPortConfiguration

Create Port Mirroring Configuration


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/configurations

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/configurations"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createPortConfiguration(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createPortConfiguration");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createPortConfiguration(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createPortConfiguration");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Create Port Mirroring Configuration
[apiInstance createPortConfigurationWith:version
    serviceInstanceId:serviceInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createPortConfiguration(version, serviceInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createPortConfigurationExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Create Port Mirroring Configuration
                apiInstance.createPortConfiguration(version, serviceInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.createPortConfiguration: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->createPortConfiguration($version, $serviceInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->createPortConfiguration: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->createPortConfiguration(version => $version, serviceInstanceId => $serviceInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->createPortConfiguration: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Create Port Mirroring Configuration
    api_instance.create_port_configuration(version, serviceInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->createPortConfiguration: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


createServiceInstance

Create a Service Instance on a version provided


/onap/so/infra/serviceInstantiation/{version}/serviceInstances

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createServiceInstance(version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createServiceInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createServiceInstance(version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createServiceInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *body = body_example; //  (optional)

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

// Create a Service Instance on a version provided
[apiInstance createServiceInstanceWith:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createServiceInstance(version, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createServiceInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Create a Service Instance on a version provided
                apiInstance.createServiceInstance(version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.createServiceInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->createServiceInstance($version, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->createServiceInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->createServiceInstance(version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->createServiceInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # Create a Service Instance on a version provided
    api_instance.create_service_instance(version, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->createServiceInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


createVfModuleInstance

Create VfModule on a specified version, serviceInstance and vnfInstance


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/vfModules

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/vfModules"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createVfModuleInstance(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createVfModuleInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createVfModuleInstance(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createVfModuleInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Create VfModule on a specified version, serviceInstance and vnfInstance
[apiInstance createVfModuleInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createVfModuleInstance(version, serviceInstanceId, vnfInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createVfModuleInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Create VfModule on a specified version, serviceInstance and vnfInstance
                apiInstance.createVfModuleInstance(version, serviceInstanceId, vnfInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.createVfModuleInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->createVfModuleInstance($version, $serviceInstanceId, $vnfInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->createVfModuleInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->createVfModuleInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->createVfModuleInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Create VfModule on a specified version, serviceInstance and vnfInstance
    api_instance.create_vf_module_instance(version, serviceInstanceId, vnfInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->createVfModuleInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
vnfInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


createVnfInstance

Create VNF on a specified version and serviceInstance


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createVnfInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createVnfInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createVnfInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createVnfInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Create VNF on a specified version and serviceInstance
[apiInstance createVnfInstanceWith:version
    serviceInstanceId:serviceInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createVnfInstance(version, serviceInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createVnfInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Create VNF on a specified version and serviceInstance
                apiInstance.createVnfInstance(version, serviceInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.createVnfInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->createVnfInstance($version, $serviceInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->createVnfInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->createVnfInstance(version => $version, serviceInstanceId => $serviceInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->createVnfInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Create VNF on a specified version and serviceInstance
    api_instance.create_vnf_instance(version, serviceInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->createVnfInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


createVolumeGroupInstance

Create VolumeGroup on a specified version, serviceInstance, vnfInstance


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/volumeGroups

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/volumeGroups"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createVolumeGroupInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createVolumeGroupInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Create VolumeGroup on a specified version, serviceInstance, vnfInstance
[apiInstance createVolumeGroupInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createVolumeGroupInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Create VolumeGroup on a specified version, serviceInstance, vnfInstance
                apiInstance.createVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.createVolumeGroupInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->createVolumeGroupInstance($version, $serviceInstanceId, $vnfInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->createVolumeGroupInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->createVolumeGroupInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->createVolumeGroupInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Create VolumeGroup on a specified version, serviceInstance, vnfInstance
    api_instance.create_volume_group_instance(version, serviceInstanceId, vnfInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->createVolumeGroupInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
vnfInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


deactivateAndCloudDeleteVfModuleInstance

Deactivate and Cloud Delete VfModule instance


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/vfModules/{vfmoduleInstanceId}/deactivateAndCloudDelete

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/vfModules/{vfmoduleInstanceId}/deactivateAndCloudDelete"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deactivateAndCloudDeleteVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deactivateAndCloudDeleteVfModuleInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deactivateAndCloudDeleteVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deactivateAndCloudDeleteVfModuleInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *vfmoduleInstanceId = vfmoduleInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Deactivate and Cloud Delete VfModule instance
[apiInstance deactivateAndCloudDeleteVfModuleInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    vfmoduleInstanceId:vfmoduleInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var vfmoduleInstanceId = vfmoduleInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deactivateAndCloudDeleteVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deactivateAndCloudDeleteVfModuleInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var vfmoduleInstanceId = vfmoduleInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Deactivate and Cloud Delete VfModule instance
                apiInstance.deactivateAndCloudDeleteVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.deactivateAndCloudDeleteVfModuleInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deactivateAndCloudDeleteVfModuleInstance($version, $serviceInstanceId, $vnfInstanceId, $vfmoduleInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->deactivateAndCloudDeleteVfModuleInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $vfmoduleInstanceId = vfmoduleInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deactivateAndCloudDeleteVfModuleInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, vfmoduleInstanceId => $vfmoduleInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->deactivateAndCloudDeleteVfModuleInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
vfmoduleInstanceId = vfmoduleInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Deactivate and Cloud Delete VfModule instance
    api_instance.deactivate_and_cloud_delete_vf_module_instance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->deactivateAndCloudDeleteVfModuleInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
vnfInstanceId*
String
Required
vfmoduleInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


deactivatePort

Deactivate Port Mirroring


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/configurations/{configurationInstanceId}/deactivate

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/configurations/{configurationInstanceId}/deactivate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String configurationInstanceId = configurationInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deactivatePort(version, serviceInstanceId, configurationInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deactivatePort");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String configurationInstanceId = configurationInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deactivatePort(version, serviceInstanceId, configurationInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deactivatePort");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *configurationInstanceId = configurationInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Deactivate Port Mirroring
[apiInstance deactivatePortWith:version
    serviceInstanceId:serviceInstanceId
    configurationInstanceId:configurationInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var configurationInstanceId = configurationInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deactivatePort(version, serviceInstanceId, configurationInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deactivatePortExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var configurationInstanceId = configurationInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Deactivate Port Mirroring
                apiInstance.deactivatePort(version, serviceInstanceId, configurationInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.deactivatePort: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$configurationInstanceId = configurationInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deactivatePort($version, $serviceInstanceId, $configurationInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->deactivatePort: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $configurationInstanceId = configurationInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deactivatePort(version => $version, serviceInstanceId => $serviceInstanceId, configurationInstanceId => $configurationInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->deactivatePort: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
configurationInstanceId = configurationInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Deactivate Port Mirroring
    api_instance.deactivate_port(version, serviceInstanceId, configurationInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->deactivatePort: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
configurationInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


deactivateServiceInstance

Deactivate provided Service Instance


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/deactivate

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/deactivate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deactivateServiceInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deactivateServiceInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deactivateServiceInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deactivateServiceInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Deactivate provided Service Instance
[apiInstance deactivateServiceInstanceWith:version
    serviceInstanceId:serviceInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deactivateServiceInstance(version, serviceInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deactivateServiceInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Deactivate provided Service Instance
                apiInstance.deactivateServiceInstance(version, serviceInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.deactivateServiceInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deactivateServiceInstance($version, $serviceInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->deactivateServiceInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deactivateServiceInstance(version => $version, serviceInstanceId => $serviceInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->deactivateServiceInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Deactivate provided Service Instance
    api_instance.deactivate_service_instance(version, serviceInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->deactivateServiceInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


deleteNetworkInstance

Delete provided Network instance


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/networks/{networkInstanceId}

Usage and SDK Samples

curl -X DELETE "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/networks/{networkInstanceId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String networkInstanceId = networkInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteNetworkInstance(version, serviceInstanceId, networkInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deleteNetworkInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String networkInstanceId = networkInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteNetworkInstance(version, serviceInstanceId, networkInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deleteNetworkInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *networkInstanceId = networkInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Delete provided Network instance
[apiInstance deleteNetworkInstanceWith:version
    serviceInstanceId:serviceInstanceId
    networkInstanceId:networkInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var networkInstanceId = networkInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteNetworkInstance(version, serviceInstanceId, networkInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteNetworkInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var networkInstanceId = networkInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Delete provided Network instance
                apiInstance.deleteNetworkInstance(version, serviceInstanceId, networkInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.deleteNetworkInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$networkInstanceId = networkInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deleteNetworkInstance($version, $serviceInstanceId, $networkInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->deleteNetworkInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $networkInstanceId = networkInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deleteNetworkInstance(version => $version, serviceInstanceId => $serviceInstanceId, networkInstanceId => $networkInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->deleteNetworkInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
networkInstanceId = networkInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Delete provided Network instance
    api_instance.delete_network_instance(version, serviceInstanceId, networkInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->deleteNetworkInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
networkInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


deletePortConfiguration

Delete provided Port


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/configurations/{configurationInstanceId}

Usage and SDK Samples

curl -X DELETE "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/configurations/{configurationInstanceId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String configurationInstanceId = configurationInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deletePortConfiguration(version, serviceInstanceId, configurationInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deletePortConfiguration");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String configurationInstanceId = configurationInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deletePortConfiguration(version, serviceInstanceId, configurationInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deletePortConfiguration");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *configurationInstanceId = configurationInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Delete provided Port
[apiInstance deletePortConfigurationWith:version
    serviceInstanceId:serviceInstanceId
    configurationInstanceId:configurationInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var configurationInstanceId = configurationInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deletePortConfiguration(version, serviceInstanceId, configurationInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deletePortConfigurationExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var configurationInstanceId = configurationInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Delete provided Port
                apiInstance.deletePortConfiguration(version, serviceInstanceId, configurationInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.deletePortConfiguration: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$configurationInstanceId = configurationInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deletePortConfiguration($version, $serviceInstanceId, $configurationInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->deletePortConfiguration: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $configurationInstanceId = configurationInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deletePortConfiguration(version => $version, serviceInstanceId => $serviceInstanceId, configurationInstanceId => $configurationInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->deletePortConfiguration: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
configurationInstanceId = configurationInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Delete provided Port
    api_instance.delete_port_configuration(version, serviceInstanceId, configurationInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->deletePortConfiguration: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
configurationInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


deleteServiceInstance

Delete provided Service Instance


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}

Usage and SDK Samples

curl -X DELETE "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteServiceInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deleteServiceInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteServiceInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deleteServiceInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Delete provided Service Instance
[apiInstance deleteServiceInstanceWith:version
    serviceInstanceId:serviceInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteServiceInstance(version, serviceInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteServiceInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Delete provided Service Instance
                apiInstance.deleteServiceInstance(version, serviceInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.deleteServiceInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deleteServiceInstance($version, $serviceInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->deleteServiceInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deleteServiceInstance(version => $version, serviceInstanceId => $serviceInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->deleteServiceInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Delete provided Service Instance
    api_instance.delete_service_instance(version, serviceInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->deleteServiceInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


deleteVfModuleInstance

Delete provided VfModule instance


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/vfModules/{vfmoduleInstanceId}

Usage and SDK Samples

curl -X DELETE "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/vfModules/{vfmoduleInstanceId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deleteVfModuleInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deleteVfModuleInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *vfmoduleInstanceId = vfmoduleInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Delete provided VfModule instance
[apiInstance deleteVfModuleInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    vfmoduleInstanceId:vfmoduleInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var vfmoduleInstanceId = vfmoduleInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteVfModuleInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var vfmoduleInstanceId = vfmoduleInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Delete provided VfModule instance
                apiInstance.deleteVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.deleteVfModuleInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deleteVfModuleInstance($version, $serviceInstanceId, $vnfInstanceId, $vfmoduleInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->deleteVfModuleInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $vfmoduleInstanceId = vfmoduleInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deleteVfModuleInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, vfmoduleInstanceId => $vfmoduleInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->deleteVfModuleInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
vfmoduleInstanceId = vfmoduleInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Delete provided VfModule instance
    api_instance.delete_vf_module_instance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->deleteVfModuleInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
vnfInstanceId*
String
Required
vfmoduleInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


deleteVnfInstance

Delete provided VNF instance


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}

Usage and SDK Samples

curl -X DELETE "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteVnfInstance(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deleteVnfInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteVnfInstance(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deleteVnfInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Delete provided VNF instance
[apiInstance deleteVnfInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteVnfInstance(version, serviceInstanceId, vnfInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteVnfInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Delete provided VNF instance
                apiInstance.deleteVnfInstance(version, serviceInstanceId, vnfInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.deleteVnfInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deleteVnfInstance($version, $serviceInstanceId, $vnfInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->deleteVnfInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deleteVnfInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->deleteVnfInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Delete provided VNF instance
    api_instance.delete_vnf_instance(version, serviceInstanceId, vnfInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->deleteVnfInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
vnfInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


deleteVolumeGroupInstance

Delete provided VolumeGroup instance


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/volumeGroups/{volumeGroupInstanceId}

Usage and SDK Samples

curl -X DELETE "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/volumeGroups/{volumeGroupInstanceId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String volumeGroupInstanceId = volumeGroupInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, volumeGroupInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deleteVolumeGroupInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String volumeGroupInstanceId = volumeGroupInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, volumeGroupInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deleteVolumeGroupInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *volumeGroupInstanceId = volumeGroupInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Delete provided VolumeGroup instance
[apiInstance deleteVolumeGroupInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    volumeGroupInstanceId:volumeGroupInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var volumeGroupInstanceId = volumeGroupInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, volumeGroupInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteVolumeGroupInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var volumeGroupInstanceId = volumeGroupInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Delete provided VolumeGroup instance
                apiInstance.deleteVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, volumeGroupInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.deleteVolumeGroupInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$volumeGroupInstanceId = volumeGroupInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deleteVolumeGroupInstance($version, $serviceInstanceId, $vnfInstanceId, $volumeGroupInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->deleteVolumeGroupInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $volumeGroupInstanceId = volumeGroupInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deleteVolumeGroupInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, volumeGroupInstanceId => $volumeGroupInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->deleteVolumeGroupInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
volumeGroupInstanceId = volumeGroupInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Delete provided VolumeGroup instance
    api_instance.delete_volume_group_instance(version, serviceInstanceId, vnfInstanceId, volumeGroupInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->deleteVolumeGroupInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
vnfInstanceId*
String
Required
volumeGroupInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


disablePort

Disable Port Mirroring


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/configurations/{configurationInstanceId}/disablePort

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/configurations/{configurationInstanceId}/disablePort"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String configurationInstanceId = configurationInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.disablePort(version, serviceInstanceId, configurationInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#disablePort");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String configurationInstanceId = configurationInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.disablePort(version, serviceInstanceId, configurationInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#disablePort");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *configurationInstanceId = configurationInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Disable Port Mirroring
[apiInstance disablePortWith:version
    serviceInstanceId:serviceInstanceId
    configurationInstanceId:configurationInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var configurationInstanceId = configurationInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.disablePort(version, serviceInstanceId, configurationInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class disablePortExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var configurationInstanceId = configurationInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Disable Port Mirroring
                apiInstance.disablePort(version, serviceInstanceId, configurationInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.disablePort: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$configurationInstanceId = configurationInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->disablePort($version, $serviceInstanceId, $configurationInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->disablePort: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $configurationInstanceId = configurationInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->disablePort(version => $version, serviceInstanceId => $serviceInstanceId, configurationInstanceId => $configurationInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->disablePort: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
configurationInstanceId = configurationInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Disable Port Mirroring
    api_instance.disable_port(version, serviceInstanceId, configurationInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->disablePort: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
configurationInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


enablePort

Enable Port Mirroring


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/configurations/{configurationInstanceId}/enablePort

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/configurations/{configurationInstanceId}/enablePort"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String configurationInstanceId = configurationInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.enablePort(version, serviceInstanceId, configurationInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#enablePort");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String configurationInstanceId = configurationInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.enablePort(version, serviceInstanceId, configurationInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#enablePort");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *configurationInstanceId = configurationInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Enable Port Mirroring
[apiInstance enablePortWith:version
    serviceInstanceId:serviceInstanceId
    configurationInstanceId:configurationInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var configurationInstanceId = configurationInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.enablePort(version, serviceInstanceId, configurationInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class enablePortExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var configurationInstanceId = configurationInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Enable Port Mirroring
                apiInstance.enablePort(version, serviceInstanceId, configurationInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.enablePort: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$configurationInstanceId = configurationInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->enablePort($version, $serviceInstanceId, $configurationInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->enablePort: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $configurationInstanceId = configurationInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->enablePort(version => $version, serviceInstanceId => $serviceInstanceId, configurationInstanceId => $configurationInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->enablePort: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
configurationInstanceId = configurationInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Enable Port Mirroring
    api_instance.enable_port(version, serviceInstanceId, configurationInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->enablePort: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
configurationInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


inPlaceSoftwareUpdate

Perform VNF software update


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/inPlaceSoftwareUpdate

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/inPlaceSoftwareUpdate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.inPlaceSoftwareUpdate(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#inPlaceSoftwareUpdate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.inPlaceSoftwareUpdate(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#inPlaceSoftwareUpdate");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Perform VNF software update
[apiInstance inPlaceSoftwareUpdateWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.inPlaceSoftwareUpdate(version, serviceInstanceId, vnfInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class inPlaceSoftwareUpdateExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Perform VNF software update
                apiInstance.inPlaceSoftwareUpdate(version, serviceInstanceId, vnfInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.inPlaceSoftwareUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->inPlaceSoftwareUpdate($version, $serviceInstanceId, $vnfInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->inPlaceSoftwareUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->inPlaceSoftwareUpdate(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->inPlaceSoftwareUpdate: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Perform VNF software update
    api_instance.in_place_software_update(version, serviceInstanceId, vnfInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->inPlaceSoftwareUpdate: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
vnfInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


removeRelationships

Remove Relationships from Service Instance


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/removeRelationships

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/removeRelationships"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.removeRelationships(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#removeRelationships");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.removeRelationships(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#removeRelationships");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Remove Relationships from Service Instance
[apiInstance removeRelationshipsWith:version
    serviceInstanceId:serviceInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.removeRelationships(version, serviceInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class removeRelationshipsExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Remove Relationships from Service Instance
                apiInstance.removeRelationships(version, serviceInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.removeRelationships: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->removeRelationships($version, $serviceInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->removeRelationships: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->removeRelationships(version => $version, serviceInstanceId => $serviceInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->removeRelationships: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Remove Relationships from Service Instance
    api_instance.remove_relationships(version, serviceInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->removeRelationships: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


replaceVfModuleInstance

Create VfModule on a specified version, serviceInstance and vnfInstance


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/vfModules/{vfmoduleInstanceId}/replace

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/vfModules/{vfmoduleInstanceId}/replace"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.replaceVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#replaceVfModuleInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.replaceVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#replaceVfModuleInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *vfmoduleInstanceId = vfmoduleInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Create VfModule on a specified version, serviceInstance and vnfInstance
[apiInstance replaceVfModuleInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    vfmoduleInstanceId:vfmoduleInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var vfmoduleInstanceId = vfmoduleInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.replaceVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class replaceVfModuleInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var vfmoduleInstanceId = vfmoduleInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Create VfModule on a specified version, serviceInstance and vnfInstance
                apiInstance.replaceVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.replaceVfModuleInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->replaceVfModuleInstance($version, $serviceInstanceId, $vnfInstanceId, $vfmoduleInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->replaceVfModuleInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $vfmoduleInstanceId = vfmoduleInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->replaceVfModuleInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, vfmoduleInstanceId => $vfmoduleInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->replaceVfModuleInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
vfmoduleInstanceId = vfmoduleInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Create VfModule on a specified version, serviceInstance and vnfInstance
    api_instance.replace_vf_module_instance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->replaceVfModuleInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
vnfInstanceId*
String
Required
vfmoduleInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


replaceVnfInstance

Replace provided VNF instance


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/replace

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/replace"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.replaceVnfInstance(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#replaceVnfInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.replaceVnfInstance(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#replaceVnfInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Replace provided VNF instance
[apiInstance replaceVnfInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.replaceVnfInstance(version, serviceInstanceId, vnfInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class replaceVnfInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Replace provided VNF instance
                apiInstance.replaceVnfInstance(version, serviceInstanceId, vnfInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.replaceVnfInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->replaceVnfInstance($version, $serviceInstanceId, $vnfInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->replaceVnfInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->replaceVnfInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->replaceVnfInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Replace provided VNF instance
    api_instance.replace_vnf_instance(version, serviceInstanceId, vnfInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->replaceVnfInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
vnfInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


scaleOutVfModule

VF Auto Scale Out


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/vfModules/scaleOut

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/vfModules/scaleOut"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.scaleOutVfModule(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#scaleOutVfModule");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.scaleOutVfModule(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#scaleOutVfModule");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *body = body_example; //  (optional)

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

// VF Auto Scale Out
[apiInstance scaleOutVfModuleWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.scaleOutVfModule(version, serviceInstanceId, vnfInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class scaleOutVfModuleExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // VF Auto Scale Out
                apiInstance.scaleOutVfModule(version, serviceInstanceId, vnfInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.scaleOutVfModule: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->scaleOutVfModule($version, $serviceInstanceId, $vnfInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->scaleOutVfModule: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->scaleOutVfModule(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->scaleOutVfModule: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # VF Auto Scale Out
    api_instance.scale_out_vf_module(version, serviceInstanceId, vnfInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->scaleOutVfModule: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
vnfInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


unassignServiceInstance

Unassign Service Instance


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/unassign

Usage and SDK Samples

curl -X POST "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/unassign"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.unassignServiceInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#unassignServiceInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.unassignServiceInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#unassignServiceInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Unassign Service Instance
[apiInstance unassignServiceInstanceWith:version
    serviceInstanceId:serviceInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.unassignServiceInstance(version, serviceInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class unassignServiceInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Unassign Service Instance
                apiInstance.unassignServiceInstance(version, serviceInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.unassignServiceInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->unassignServiceInstance($version, $serviceInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->unassignServiceInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->unassignServiceInstance(version => $version, serviceInstanceId => $serviceInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->unassignServiceInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Unassign Service Instance
    api_instance.unassign_service_instance(version, serviceInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->unassignServiceInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


updateNetworkInstance

Update VolumeGroup on a specified version, serviceInstance, networkInstance


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/networks/{networkInstanceId}

Usage and SDK Samples

curl -X PUT "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/networks/{networkInstanceId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String networkInstanceId = networkInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateNetworkInstance(version, serviceInstanceId, networkInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#updateNetworkInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String networkInstanceId = networkInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateNetworkInstance(version, serviceInstanceId, networkInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#updateNetworkInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *networkInstanceId = networkInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Update VolumeGroup on a specified version, serviceInstance, networkInstance
[apiInstance updateNetworkInstanceWith:version
    serviceInstanceId:serviceInstanceId
    networkInstanceId:networkInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var networkInstanceId = networkInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateNetworkInstance(version, serviceInstanceId, networkInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class updateNetworkInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var networkInstanceId = networkInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Update VolumeGroup on a specified version, serviceInstance, networkInstance
                apiInstance.updateNetworkInstance(version, serviceInstanceId, networkInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.updateNetworkInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$networkInstanceId = networkInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->updateNetworkInstance($version, $serviceInstanceId, $networkInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->updateNetworkInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $networkInstanceId = networkInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->updateNetworkInstance(version => $version, serviceInstanceId => $serviceInstanceId, networkInstanceId => $networkInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->updateNetworkInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
networkInstanceId = networkInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Update VolumeGroup on a specified version, serviceInstance, networkInstance
    api_instance.update_network_instance(version, serviceInstanceId, networkInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->updateNetworkInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
networkInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


updateVfModuleInstance

Update VfModule on a specified version, serviceInstance, vnfInstance and vfModule


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/vfModules/{vfmoduleInstanceId}

Usage and SDK Samples

curl -X PUT "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/vfModules/{vfmoduleInstanceId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#updateVfModuleInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#updateVfModuleInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *vfmoduleInstanceId = vfmoduleInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Update VfModule on a specified version, serviceInstance, vnfInstance and vfModule
[apiInstance updateVfModuleInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    vfmoduleInstanceId:vfmoduleInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var vfmoduleInstanceId = vfmoduleInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class updateVfModuleInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var vfmoduleInstanceId = vfmoduleInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Update VfModule on a specified version, serviceInstance, vnfInstance and vfModule
                apiInstance.updateVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.updateVfModuleInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->updateVfModuleInstance($version, $serviceInstanceId, $vnfInstanceId, $vfmoduleInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->updateVfModuleInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $vfmoduleInstanceId = vfmoduleInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->updateVfModuleInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, vfmoduleInstanceId => $vfmoduleInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->updateVfModuleInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
vfmoduleInstanceId = vfmoduleInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Update VfModule on a specified version, serviceInstance, vnfInstance and vfModule
    api_instance.update_vf_module_instance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->updateVfModuleInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
vnfInstanceId*
String
Required
vfmoduleInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


updateVnfInstance

Update VNF on a specified version, serviceInstance and vnfInstance


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}

Usage and SDK Samples

curl -X PUT "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateVnfInstance(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#updateVnfInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateVnfInstance(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#updateVnfInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Update VNF on a specified version, serviceInstance and vnfInstance
[apiInstance updateVnfInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateVnfInstance(version, serviceInstanceId, vnfInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class updateVnfInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Update VNF on a specified version, serviceInstance and vnfInstance
                apiInstance.updateVnfInstance(version, serviceInstanceId, vnfInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.updateVnfInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->updateVnfInstance($version, $serviceInstanceId, $vnfInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->updateVnfInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->updateVnfInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->updateVnfInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Update VNF on a specified version, serviceInstance and vnfInstance
    api_instance.update_vnf_instance(version, serviceInstanceId, vnfInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->updateVnfInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
vnfInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


updateVolumeGroupInstance

Update VolumeGroup on a specified version, serviceInstance, vnfInstance and volumeGroup


/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/volumeGroups/{volumeGroupInstanceId}

Usage and SDK Samples

curl -X PUT "http://localhost/onap/so/infra/serviceInstantiation/{version}/serviceInstances/{serviceInstanceId}/vnfs/{vnfInstanceId}/volumeGroups/{volumeGroupInstanceId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String volumeGroupInstanceId = volumeGroupInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, volumeGroupInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#updateVolumeGroupInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String volumeGroupInstanceId = volumeGroupInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, volumeGroupInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#updateVolumeGroupInstance");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *volumeGroupInstanceId = volumeGroupInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Update VolumeGroup on a specified version, serviceInstance, vnfInstance and volumeGroup
[apiInstance updateVolumeGroupInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    volumeGroupInstanceId:volumeGroupInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var volumeGroupInstanceId = volumeGroupInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, volumeGroupInstanceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class updateVolumeGroupInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var volumeGroupInstanceId = volumeGroupInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Update VolumeGroup on a specified version, serviceInstance, vnfInstance and volumeGroup
                apiInstance.updateVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, volumeGroupInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.updateVolumeGroupInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$volumeGroupInstanceId = volumeGroupInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->updateVolumeGroupInstance($version, $serviceInstanceId, $vnfInstanceId, $volumeGroupInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->updateVolumeGroupInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $volumeGroupInstanceId = volumeGroupInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->updateVolumeGroupInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, volumeGroupInstanceId => $volumeGroupInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->updateVolumeGroupInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
volumeGroupInstanceId = volumeGroupInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Update VolumeGroup on a specified version, serviceInstance, vnfInstance and volumeGroup
    api_instance.update_volume_group_instance(version, serviceInstanceId, vnfInstanceId, volumeGroupInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->updateVolumeGroupInstance: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
serviceInstanceId*
String
Required
vnfInstanceId*
String
Required
volumeGroupInstanceId*
String
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


Onapsoinfratasks

queryFilters

Finds Manual Tasks


/onap/so/infra/tasks/{version}

Usage and SDK Samples

curl -X GET "http://localhost/onap/so/infra/tasks/{version}?taskId=&originalRequestId=&subscriptionServiceType=&nfRole=&buildingBlockName=&originalRequestDate=&originalRequestorId="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfratasksApi;

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

public class OnapsoinfratasksApiExample {

    public static void main(String[] args) {
        
        OnapsoinfratasksApi apiInstance = new OnapsoinfratasksApi();
        String version = version_example; // String | 
        String taskId = taskId_example; // String | 
        String originalRequestId = originalRequestId_example; // String | 
        String subscriptionServiceType = subscriptionServiceType_example; // String | 
        String nfRole = nfRole_example; // String | 
        String buildingBlockName = buildingBlockName_example; // String | 
        String originalRequestDate = originalRequestDate_example; // String | 
        String originalRequestorId = originalRequestorId_example; // String | 
        try {
            apiInstance.queryFilters(version, taskId, originalRequestId, subscriptionServiceType, nfRole, buildingBlockName, originalRequestDate, originalRequestorId);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfratasksApi#queryFilters");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfratasksApi;

public class OnapsoinfratasksApiExample {

    public static void main(String[] args) {
        OnapsoinfratasksApi apiInstance = new OnapsoinfratasksApi();
        String version = version_example; // String | 
        String taskId = taskId_example; // String | 
        String originalRequestId = originalRequestId_example; // String | 
        String subscriptionServiceType = subscriptionServiceType_example; // String | 
        String nfRole = nfRole_example; // String | 
        String buildingBlockName = buildingBlockName_example; // String | 
        String originalRequestDate = originalRequestDate_example; // String | 
        String originalRequestorId = originalRequestorId_example; // String | 
        try {
            apiInstance.queryFilters(version, taskId, originalRequestId, subscriptionServiceType, nfRole, buildingBlockName, originalRequestDate, originalRequestorId);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfratasksApi#queryFilters");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *taskId = taskId_example; //  (optional)
String *originalRequestId = originalRequestId_example; //  (optional)
String *subscriptionServiceType = subscriptionServiceType_example; //  (optional)
String *nfRole = nfRole_example; //  (optional)
String *buildingBlockName = buildingBlockName_example; //  (optional)
String *originalRequestDate = originalRequestDate_example; //  (optional)
String *originalRequestorId = originalRequestorId_example; //  (optional)

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

// Finds Manual Tasks
[apiInstance queryFiltersWith:version
    taskId:taskId
    originalRequestId:originalRequestId
    subscriptionServiceType:subscriptionServiceType
    nfRole:nfRole
    buildingBlockName:buildingBlockName
    originalRequestDate:originalRequestDate
    originalRequestorId:originalRequestorId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfratasksApi()

var version = version_example; // {String} 

var opts = { 
  'taskId': taskId_example, // {String} 
  'originalRequestId': originalRequestId_example, // {String} 
  'subscriptionServiceType': subscriptionServiceType_example, // {String} 
  'nfRole': nfRole_example, // {String} 
  'buildingBlockName': buildingBlockName_example, // {String} 
  'originalRequestDate': originalRequestDate_example, // {String} 
  'originalRequestorId': originalRequestorId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.queryFilters(version, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class queryFiltersExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfratasksApi();
            var version = version_example;  // String | 
            var taskId = taskId_example;  // String |  (optional) 
            var originalRequestId = originalRequestId_example;  // String |  (optional) 
            var subscriptionServiceType = subscriptionServiceType_example;  // String |  (optional) 
            var nfRole = nfRole_example;  // String |  (optional) 
            var buildingBlockName = buildingBlockName_example;  // String |  (optional) 
            var originalRequestDate = originalRequestDate_example;  // String |  (optional) 
            var originalRequestorId = originalRequestorId_example;  // String |  (optional) 

            try
            {
                // Finds Manual Tasks
                apiInstance.queryFilters(version, taskId, originalRequestId, subscriptionServiceType, nfRole, buildingBlockName, originalRequestDate, originalRequestorId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfratasksApi.queryFilters: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfratasksApi();
$version = version_example; // String | 
$taskId = taskId_example; // String | 
$originalRequestId = originalRequestId_example; // String | 
$subscriptionServiceType = subscriptionServiceType_example; // String | 
$nfRole = nfRole_example; // String | 
$buildingBlockName = buildingBlockName_example; // String | 
$originalRequestDate = originalRequestDate_example; // String | 
$originalRequestorId = originalRequestorId_example; // String | 

try {
    $api_instance->queryFilters($version, $taskId, $originalRequestId, $subscriptionServiceType, $nfRole, $buildingBlockName, $originalRequestDate, $originalRequestorId);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfratasksApi->queryFilters: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OnapsoinfratasksApi;

my $api_instance = WWW::SwaggerClient::OnapsoinfratasksApi->new();
my $version = version_example; # String | 
my $taskId = taskId_example; # String | 
my $originalRequestId = originalRequestId_example; # String | 
my $subscriptionServiceType = subscriptionServiceType_example; # String | 
my $nfRole = nfRole_example; # String | 
my $buildingBlockName = buildingBlockName_example; # String | 
my $originalRequestDate = originalRequestDate_example; # String | 
my $originalRequestorId = originalRequestorId_example; # String | 

eval { 
    $api_instance->queryFilters(version => $version, taskId => $taskId, originalRequestId => $originalRequestId, subscriptionServiceType => $subscriptionServiceType, nfRole => $nfRole, buildingBlockName => $buildingBlockName, originalRequestDate => $originalRequestDate, originalRequestorId => $originalRequestorId);
};
if ($@) {
    warn "Exception when calling OnapsoinfratasksApi->queryFilters: $@\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.OnapsoinfratasksApi()
version = version_example # String | 
taskId = taskId_example # String |  (optional)
originalRequestId = originalRequestId_example # String |  (optional)
subscriptionServiceType = subscriptionServiceType_example # String |  (optional)
nfRole = nfRole_example # String |  (optional)
buildingBlockName = buildingBlockName_example # String |  (optional)
originalRequestDate = originalRequestDate_example # String |  (optional)
originalRequestorId = originalRequestorId_example # String |  (optional)

try: 
    # Finds Manual Tasks
    api_instance.query_filters(version, taskId=taskId, originalRequestId=originalRequestId, subscriptionServiceType=subscriptionServiceType, nfRole=nfRole, buildingBlockName=buildingBlockName, originalRequestDate=originalRequestDate, originalRequestorId=originalRequestorId)
except ApiException as e:
    print("Exception when calling OnapsoinfratasksApi->queryFilters: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
Query parameters
Name Description
taskId
String
originalRequestId
String
subscriptionServiceType
String
nfRole
String
buildingBlockName
String
originalRequestDate
String
originalRequestorId
String

Responses

Status: default - successful operation


OnapsoinfraworkflowSpecifications

queryWorkflowSpecifications

Retrieve Workflow details based on the filter criteria


/onap/so/infra/workflowSpecifications/{version}/workflows

Usage and SDK Samples

curl -X GET "http://localhost/onap/so/infra/workflowSpecifications/{version}/workflows?resourceTarget="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OnapsoinfraworkflowSpecificationsApi;

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

public class OnapsoinfraworkflowSpecificationsApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraworkflowSpecificationsApi apiInstance = new OnapsoinfraworkflowSpecificationsApi();
        String version = version_example; // String | 
        String resourceTarget = resourceTarget_example; // String | 
        try {
            RetrievingWorkflowResponse result = apiInstance.queryWorkflowSpecifications(version, resourceTarget);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraworkflowSpecificationsApi#queryWorkflowSpecifications");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OnapsoinfraworkflowSpecificationsApi;

public class OnapsoinfraworkflowSpecificationsApiExample {

    public static void main(String[] args) {
        OnapsoinfraworkflowSpecificationsApi apiInstance = new OnapsoinfraworkflowSpecificationsApi();
        String version = version_example; // String | 
        String resourceTarget = resourceTarget_example; // String | 
        try {
            RetrievingWorkflowResponse result = apiInstance.queryWorkflowSpecifications(version, resourceTarget);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraworkflowSpecificationsApi#queryWorkflowSpecifications");
            e.printStackTrace();
        }
    }
}
String *version = version_example; // 
String *resourceTarget = resourceTarget_example; //  (optional)

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

// Retrieve Workflow details based on the filter criteria
[apiInstance queryWorkflowSpecificationsWith:version
    resourceTarget:resourceTarget
              completionHandler: ^(RetrievingWorkflowResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraworkflowSpecificationsApi()

var version = version_example; // {String} 

var opts = { 
  'resourceTarget': resourceTarget_example // {String} 
};

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

namespace Example
{
    public class queryWorkflowSpecificationsExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraworkflowSpecificationsApi();
            var version = version_example;  // String | 
            var resourceTarget = resourceTarget_example;  // String |  (optional) 

            try
            {
                // Retrieve Workflow details based on the filter criteria
                RetrievingWorkflowResponse result = apiInstance.queryWorkflowSpecifications(version, resourceTarget);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraworkflowSpecificationsApi.queryWorkflowSpecifications: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OnapsoinfraworkflowSpecificationsApi();
$version = version_example; // String | 
$resourceTarget = resourceTarget_example; // String | 

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraworkflowSpecificationsApi->new();
my $version = version_example; # String | 
my $resourceTarget = resourceTarget_example; # String | 

eval { 
    my $result = $api_instance->queryWorkflowSpecifications(version => $version, resourceTarget => $resourceTarget);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OnapsoinfraworkflowSpecificationsApi->queryWorkflowSpecifications: $@\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.OnapsoinfraworkflowSpecificationsApi()
version = version_example # String | 
resourceTarget = resourceTarget_example # String |  (optional)

try: 
    # Retrieve Workflow details based on the filter criteria
    api_response = api_instance.query_workflow_specifications(version, resourceTarget=resourceTarget)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OnapsoinfraworkflowSpecificationsApi->queryWorkflowSpecifications: %s\n" % e)

Parameters

Path parameters
Name Description
version*
String
Required
Query parameters
Name Description
resourceTarget
String

Responses

Status: default - List of workflow specifications on successful operation