Slice Manager

Contents

The subpackage fabrictestbed.slice_manager contains the class SliceManager, and the enum Status.

from fabrictestbed.slice_manager import SliceManager, Status

Enum Status

The fabrictestbed.slice_manager.Status enum is used to indicate whether something was successful or not. It is returned by, for example, function calls to indicate whether it was successful or not.

1	OK Operation executed successfully.
2	INVALID_ARGUMENTS Arguments are invalid.
3	FAILURE Operation was unsuccessful.

from fabrictestbed.slice_manager import Status

Class SliceManager

The fabrictestbed.slice_manager.SliceManager class is used for things like communicating with the FABRIC test bed to determine the state of your slices, slivers, etc…, as well as issuing requests to reserve resources.

Constructor

SliceManager(*, cm_host: str, oc_host: str, token_location: str = None, project_name: str = ‘all’, scope: str = ‘all’)

`Param`	cm_host Credit Manager Host. It should be set to the value of the environment variable ‘FABRIC_CREDMGR_HOST’.
`Param`	oc_host Orchestrator Client Host. It should be set to the value of the environment variable ‘FABRIC_ORCHESTRATOR_HOST’.
`Param`	token_location Todo
`Param`	project_name A string that names the project.
`Param`	scope Possible values: ‘cf’, ‘mf’, ‘all’. Todo: ask about the concept of a scope.

Create Slice

The create function lets you create a slice according to the resources provided in the slice_graph variable.

create(self, *, token: str, slice_name: str, ssh_key: str, topology: fim.user.topology.ExperimentTopology = None, slice_graph: str = None) -> Tuple[fabric_cf.orchestrator.orchestrator_proxy.Status, Union[Exception, List[fabric_cf.orchestrator.elements.reservation.Reservation]]]

`Param`	token The FABRIC identity token. It can be retrieved (or renewed if expired) by issuing slice_manager.refresh_tokens().
`Param` `str`	slice_name A string that names the slice.
`Param` `str`	ssh_key The public key of an ssh key-pair (which is typically in a file named ‘id_rsa.pub’). The nodes in the slice can later be accessed using the private key of the key-pair. You typically need to read the public key file and pass it to this parameter.
`Param`	topology Todo: what is topology?
`Param` `str`	slice_graph Slice graph string. A graph string can be generated using the slice_editor subpackage. See fabrictestbed.slice_editor.
`Return`	Tuple(Status, Slivers/Exception) Status is fabrictestbed.slice_manager.Status. Slivers/Exception contains, in case of success, a JSON containing the slivers created. In case of failure, it contains an Exception. Todo: Should we state the “Reservation” object as something standard? Or do we just use it internally and not let the user care about it? [{ “graph_node_id”: “fe716383-8619-4bce-8dc8-9c432a16349a”, Todo: what is this? “join_state”: “None_”, Todo: what is this? “lease_end”: The date and time at which the resource will be deleted. “reservation_id”: The ID of the resource. “reservation_state”: The reservation state (whether it’s running or configuring …etc). Todo: List all possibilities and explain them? “resource_type”: The type of the resource or sliver. See NodeType. “slice_id”: The ID of the slice in which the resource (or the sliver) is contained. }]

status, reservations = slice_manager.create(

                    slice_name='JupyterSlice2',

                    slice_graph=slice_graph,

                    ssh_key=ssh_key)

Todo / Note: There’s a mismatch between the docs that we get with python’s help() function and the code.

Delete Slice

The delete function allows you to delete a slice. You specify the slice by providing its ID through the slice_id parameter.

delete(self, *, slice_id: str) -> Tuple[fabric_cf.orchestrator.orchestrator_proxy.Status, Union[Exception, NoneType]]

`Param`	slice_id The slice ID of the slice to be deleted
`Return`	Tuple(Status, Exception) Status is fabrictestbed.slice_manager.Status. Exception is either None or, in case of failure, contains an Exception.

status, result = slice_manager.delete(slice_id=slice_id)

Query Slices

The slices function gets information about all slices.

slices(self) -> Tuple[fabric_cf.orchestrator.orchestrator_proxy.Status, Union[Exception, List[fabric_cf.orchestrator.elements.slice.Slice]]]

Return Tuple(Status, Slices/Exception)
Status is fabrictestbed.slice_manager.Status.
Slices/Exception contains, in case of success, a JSON containing an array of slices and information about them.
In case of failure, it contains an Exception.
{
“graph_id”: A unique string that identifies the graph. See the concept of a graph.
“slice_id”: A unique string that identifies the slice.
“slice_name”: The name that was given to the slice.
“slice_state”: The state of the slice and whether it’s ready to function.
“StableOK” means that the slice is in a ready state and you can access the machines that you have created.
Todo: enumerate?
}

`Return`	Tuple(Status, Slices/Exception) Status is fabrictestbed.slice_manager.Status. Slices/Exception contains, in case of success, a JSON containing an array of slices and information about them. In case of failure, it contains an Exception. { “graph_id”: A unique string that identifies the graph. See the concept of a graph. “slice_id”: A unique string that identifies the slice. “slice_name”: The name that was given to the slice. “slice_state”: The state of the slice and whether it’s ready to function. “StableOK” means that the slice is in a ready state and you can access the machines that you have created. Todo: enumerate? }

status, slices = slice_manager.slices()

Get Slice

The get_slice function lets you view a slice’s information.

get_slice(self, *, slice_id: str) -> Tuple[fabric_cf.orchestrator.orchestrator_proxy.Status, Union[Exception, fim.user.topology.ExperimentTopology]]

`Param`	slice_id The slice ID of the slice to view information of.
`Return`	Tuple(Status, Slice/Exception) Status is fabrictestbed.slice_manager.Status. Slices/Exception contains, in case of success, information about the slice requested. In case of failure, it contains an Exception. { core: Total cores ram: Total amount of RAM disk: Total amount of disk space } Node name [Node type]: { core: Number of cores ram: Amount of RAM disk: Amount of disk space }

status, slice_obj = slice_manager.get_slice(slice_id=slice_id)

Refresh Tokens

Use this function to refresh the tokens. The function generates a new identity token and a new refresh token.
User is expected to invoke refresh token API (this function) before invoking any other APIs (functions) to ensure the token is not expired.
User is also expected to update the returned refresh token in the JupyterHub environment.

refresh_tokens(self) -> Tuple[str, str]

`Return`	Tuple(id_token, refresh_token) id_token is the identity token. See the concept of identity tokens. refresh_token is the refresh token. See the concept of refresh tokens.
`Raises`	SliceManagerException(id_token)

id_token, refresh_token = slice_manager.refresh_tokens()

Renew Slice

The renew function lets you extend the end time of a lease.

renew(self, *, slice_id: str, new_lease_end_time: str) -> Tuple[fabric_cf.orchestrator.orchestrator_proxy.Status, Union[Exception, List, NoneType]]

`Param`	slice_id The ID of the slice to be renewed.
`Param`	new_lease_end_time A date and time string that specifies the requested end date of the lease. Format: “%Y-%m-%d %H:%M:%S”. Example: “2022-01-01 00:00:00”.
`Return`	Tuple(Status, None/Reservations) Status is fabrictestbed.slice_manager.Status. None/Reservations contains a list of reservation IDs of reservations that couldn’t be extended, or None in case there were no issues.

slice_manager.renew(slice_id=slices[0].slice_id,

                    new_lease_end_time="2023-01-01 00:00:00")

Query Resources

The resources function lets you get the resources available for reservation.

resources(self, *, level: int = 1) -> Tuple[fabric_cf.orchestrator.orchestrator_proxy.Status, Union[Exception, fim.user.topology.AdvertizedTopology]]

Param level
The level of details.

Return Tuple(Status, Resources/Exception)
Status is fabrictestbed.slice_manager.Status.
Resources/Exeption contains, in case of success, a description of the resources available.
In case of failure, it contains an Exception.
Site Name: {
Number of CPUs: Available/Total,
core: 90/96, Todo: what are cores?
Amount of RAM: Available/Total (in Gigabytes),
Amount of storage: Available/Total (in Gigabytes),
Units: Available/Total,
}
Components:
Component name: component description { [disk: Available/Total (in Gigabytes)], units: Available/Total }
Site Interfaces:

`Param`	level The level of details.
`Return`	Tuple(Status, Resources/Exception) Status is fabrictestbed.slice_manager.Status. Resources/Exeption contains, in case of success, a description of the resources available. In case of failure, it contains an Exception. Site Name: { Number of CPUs: Available/Total, core: 90/96, Todo: what are cores? Amount of RAM: Available/Total (in Gigabytes), Amount of storage: Available/Total (in Gigabytes), Units: Available/Total, } Components: Component name: component description { [disk: Available/Total (in Gigabytes)], units: Available/Total } Site Interfaces:

status, advertised_topology = slice_manager.resources()

Note: revoke is bugged.

(‘INTERNAL SERVER ERROR’, ‘”error=\\”server_error\\”\\nerror_description=\\”class+edu.uiuc.ncsa.myproxy.oa4mp.oauth2.storage.OA2SQLTStore
+cannot+be+cast+to+class+edu.uiuc.ncsa.myproxy.oa4mp.oauth2.OA2SE+%28edu.uiuc.ncsa.myproxy.oa4mp.oauth2.storage.OA2SQLTStore
+and+edu.uiuc.ncsa.myproxy.oa4mp.oauth2.OA2SE+are+in+unnamed+module+of+loader+org.apache.catalina.loader.WebappClassLoader+%40748cc258%29\\”\\n”\n’)

Revoke Token

The revoke_token function lets you revoke or invalidate the refresh token.

revoke_token(self, refresh_token: str = None) -> Tuple[fabric_cf.orchestrator.orchestrator_proxy.Status, Any]

`Param` `str`	refresh_token The FABRIC refresh token that is initially stored in the evironment variable ‘CILOGON_REFRESH_TOKEN’. It can be renewed by issuing slice_manager.refresh_tokens().
`Return`	response Todo: waiting for it to get fixed. Also the API changed. Try it again.
`Raises`	Exception

slice_manager.revoke_token(refresh_token=refresh_token)

Get Slice Status

The slice_status lets you get status information about a slice. You can specify the slice by passing in its ID to the slice_id parameter.

slice_status(self, *, slice_id: str) -> Tuple[fabric_cf.orchestrator.orchestrator_proxy.Status, Union[Exception, fabric_cf.orchestrator.elements.slice.Slice]]

Param slice_id
The ID of the slice that you want to see the status of.

Return Tuple(Status, SliceStatus/Exception)
Status is fabrictestbed.slice_manager.Status.
SliceStatus/Exception contains, in case of success, a JSON containing the status of the slice.
In case of failure, it contains an Exception.
{
“graph_id”: A unique string that identifies the graph. See the concept of a graph.
“slice_id”: A unique string that identifies the slice.
“slice_name”: The name that was given to the slice.
“slice_state”: The state of the slice and whether it’s ready to function.
“StableOK” means that the slice is in a ready state and you can access the machines that you have created.
Todo: enumerate?
}

`Param`	slice_id The ID of the slice that you want to see the status of.
`Return`	Tuple(Status, SliceStatus/Exception) Status is fabrictestbed.slice_manager.Status. SliceStatus/Exception contains, in case of success, a JSON containing the status of the slice. In case of failure, it contains an Exception. { “graph_id”: A unique string that identifies the graph. See the concept of a graph. “slice_id”: A unique string that identifies the slice. “slice_name”: The name that was given to the slice. “slice_state”: The state of the slice and whether it’s ready to function. “StableOK” means that the slice is in a ready state and you can access the machines that you have created. Todo: enumerate? }

status, slice_status = slice_manager.slice_status(slice_id=slice_id)

Get Sliver Status

The sliver_status lets you get information about a sliver (which is typically a node in your slice).

sliver_status(self, *, slice_id: str, sliver_id: str) -> Tuple[fabric_cf.orchestrator.orchestrator_proxy.Status, Union[Exception, fabric_cf.orchestrator.elements.reservation.Reservation]]

`Param`	slice_id The slice ID of the slice that contains the sliver. It can be found in the object returned from the .create() call. You can set it to the “slice_id” variable. See .create().
`Param`	sliver_id The sliver ID of the sliver you want to get information about. It can be found in the object returned from the .create() call. You can set it to the “reservation_id” variable. See .create().
`Return`	Tuple(Status, SliverStatus/Exception) Status is fabrictestbed.slice_manager.Status. SliverStatus/Exception contains, in case of success, a JSON containing the status of the requested sliver. In case of failure, it contains an Exception. { “capacities”: “{\”core\”: Number of cores, \”disk\”: Amount of disk space, \”ram\”: Amount of RAM}”, “graph_node_id”: An ID that identifies the graph. See the concept of a graph. “join_state”: “NoJoin”, Todo: what is this? “labels”: Labels given to the sliver, if any. “management_ip”: The IP address that can be used to access the sliver, typically using SSH. “name”: The name given to the sliver. “notices”: A string contining details. “reservation_id”: The ID of the sliver. “reservation_state”: The reservation state (whether it’s running or configuring …etc). Todo: List all possibilities and explain them? “resource_type”: The type of the sliver. See NodeType. “site”: The site at which the sliver is. “slice_id”: The ID of the slice in which the sliver (or the sliver) is contained. }

status, sliver_status = slice_manager.sliver_status(

                    slice_id=slice_id,

                    sliver_id=s.reservation_id)

Query Slivers

The slivers function lets you get information about all slivers.

slivers(self, *, slice_id: str, sliver_id: str = None) -> Tuple[fabric_cf.orchestrator.orchestrator_proxy.Status, Union[Exception, List[fabric_cf.orchestrator.elements.reservation.Reservation]]]

`Param`	slice_id The slice ID to be queried. It can be found in the object returned from the .create() call. You can set it to the “slice_id” variable. See .create().
`Param` `optional`	sliver_id The sliver ID to be queried. It can be found in the object returned from the .create() call. You can set it to the “reservation_id” variable. See .create().
`Return`	Tuple(Status, SliversStatus/Exception) Status is fabrictestbed.slice_manager.Status. SliversStatus/Exception contains, in case of success, a JSON containing an array containing the status of all the slivers. In case of failure, it contains an Exception. [{ “capacities”: “{\”core\”: Number of cores, \”disk\”: Amount of disk space, \”ram\”: Amount of RAM}”, “graph_node_id”: An ID that identifies the graph. See the concept of a graph. “join_state”: “NoJoin”, Todo: what is this? “labels”: Labels given to the sliver, if any. “management_ip”: The IP address that can be used to access the sliver, typically using SSH. “name”: The name given to the sliver. “notices”: A string contining details. “reservation_id”: The ID of the sliver. “reservation_state”: The reservation state (whether it’s running or configuring …etc). Todo: List all possibilities and explain them? “resource_type”: The type of the sliver. See NodeType. “site”: The site at which the sliver is. “slice_id”: The ID of the slice in which the sliver (or the sliver) is contained. }]

status, slivers = slice_manager.slivers(

                    slice_id=reservations[1].slice_id,

                    sliver_id=reservations[1].reservation_id)

Updated on June 2, 2023

Was this article helpful?

Yes No

Having problems?

Try searching or asking questions in the FABRIC community forums!

Go to Forums