module Cmds = Xapi_storage.Control.Sr(Cmdlinergen.Gen ())

Cmdliner.Term.eval_choice default_cmd (List.map (fun t -> t rpc) (Cmds.implementation ()))

class Implementation(xapi.volume.SR_skeleton):
    pass
curl "http://example.com/api/kittens/2"

if __name__ == "__main__":
    cmd = xapi.volume.SR_commandline(Implementation())
    cmd.attach()

$ ./SR.attach
usage: SR.attach [-h] [-j] dbg uri
SR.attach: error: too few arguments

$ ./SR.attach -h
usage: SR.attach [-h] [-j] dbg uri

[attach uri]: attaches the SR to the local host. Once an SR is attached then
volumes may be manipulated.

positional arguments:
  dbg         Debug context from the caller
  uri         The Storage Repository URI

optional arguments:
  -h, --help  show this help message and exit
  -j, --json  Read json from stdin, print json to stdout

{
  "required_cluster_stack": [ "required_cluster_stack" ],
  "configuration": { "configuration": "configuration" },
  "features": [ "features" ],
  "required_api_version": "required_api_version",
  "version": "version",
  "copyright": "copyright",
  "vendor": "vendor",
  "description": "description",
  "name": "name",
  "plugin": "plugin"
}

[ "srs" ]
[]

{ "method": "Plugin.query", "params": [ { "dbg": "dbg" } ], "id": 1 }

try
    let query_result = Client.query dbg in
    ...
with Exn (Unimplemented str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.Plugin.query({ dbg: "string" })
    print(repr(results))

{
  "required_cluster_stack": [
    "required_cluster_stack_1", "required_cluster_stack_2"
  ],
  "configuration": { "field_1": "value_1", "field_2": "value_2" },
  "features": [ "features_1", "features_2" ],
  "required_api_version": "required_api_version",
  "version": "version",
  "copyright": "copyright",
  "vendor": "vendor",
  "description": "description",
  "name": "name",
  "plugin": "plugin"
}

try
    let query_result = Client.query dbg in
    ...
with Exn (Unimplemented str) -> ...

# import additional libraries if needed

class Plugin_myimplementation(Plugin_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def query(self, dbg):
        """
        Query this implementation and return its properties. This is
        called by xapi to determine whether it is compatible with xapi
        and to discover the supported features.
        """
        return {"plugin": "string", "name": "string", "description": "string", "vendor": "string", "copyright": "string", "version": "string", "required_api_version": "string", "features": ["string"], "configuration": {"string": "string"}, "required_cluster_stack": ["string"]}
    # ...

{ "method": "Plugin.ls", "params": [ { "dbg": "dbg" } ], "id": 2 }

try
    let srs = Client.ls dbg in
    ...
with Exn (Unimplemented str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.Plugin.ls({ dbg: "string" })
    print(repr(results))

[ "srs_1", "srs_2" ]

try
    let srs = Client.ls dbg in
    ...
with Exn (Unimplemented str) -> ...

# import additional libraries if needed

class Plugin_myimplementation(Plugin_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def ls(self, dbg):
        """
        [ls dbg]: returns a list of attached SRs
        """
        return ["string"]
    # ...

{ "method": "Plugin.diagnostics", "params": [ { "dbg": "dbg" } ], "id": 3 }

try
    let diagnostics = Client.diagnostics dbg in
    ...
with Exn (Unimplemented str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.Plugin.diagnostics({ dbg: "string" })
    print(repr(results))

"diagnostics"

try
    let diagnostics = Client.diagnostics dbg in
    ...
with Exn (Unimplemented str) -> ...

# import additional libraries if needed

class Plugin_myimplementation(Plugin_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def diagnostics(self, dbg):
        """
        Returns a printable set of backend diagnostic information.
        Implementations are encouraged to include any data which will
        be useful to diagnose problems. Note this data should not
        include personally-identifiable data as it is intended to be
        automatically included in bug reports.
        """
        return "string"
    # ...

[ "Unimplemented", "exnt" ]

true
false

{
  "backend_type": "backend_type",
  "extra": { "extra": "extra" },
  "params": "params"
}

{ "path": "path" }

{ "path": "path" }

{ "uri": "uri" }

[
  "XenDisk",
  {
    "backend_type": "backend_type",
    "extra": { "extra": "extra" },
    "params": "params"
  }
]
[ "BlockDevice", { "path": "path" } ]
[ "File", { "path": "path" } ]
[ "Nbd", { "uri": "uri" } ]

{
  "implementations": [
    [
      "XenDisk",
      {
        "backend_type": "backend_type",
        "extra": { "extra": "extra" },
        "params": "params"
      }
    ]
  ]
}

"sock_path"

"uri"

"domain"

{ "ranges": [ [ 0, 0 ] ], "blocksize": 0 }

[ "CopyV1", "operation" ]
[ "MirrorV1", "operation" ]

{ "progress": 0.0, "complete": true, "failed": true }

[ [ "CopyV1", "operations" ] ]
[]

{
  "method": "Datapath.open",
  "params": [ { "persistent": true, "uri": "uri", "dbg": "dbg" } ],
  "id": 31
}

try
    let () = Client.open dbg uri persistent in
    ...
with Exn (Unimplemented str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.Datapath.open({ dbg: "string", uri: "string", persistent: True })
    print(repr(results))

null

try
    let () = Client.open dbg uri persistent in
    ...
with Exn (Unimplemented str) -> ...

# import additional libraries if needed

class Datapath_myimplementation(Datapath_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def open(self, dbg, uri, persistent):
        """
        [open uri persistent] is called before a disk is attached to a VM.
        If persistent is true then care should be taken to persist all writes
        to the disk. If persistent is false then the implementation should
        configure a temporary location for writes so they can be thrown away
        on [close].
        """
    # ...

{
  "method": "Datapath.attach",
  "params": [ { "domain": "domain", "uri": "uri", "dbg": "dbg" } ],
  "id": 32
}

try
    let backend = Client.attach dbg uri domain in
    ...
with Exn (Unimplemented str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.Datapath.attach({ dbg: "string", uri: "string", domain: "string" })
    print(repr(results))

{
  "implementations": [
    [
      "XenDisk",
      {
        "backend_type": "backend_type",
        "extra": { "field_1": "value_1", "field_2": "value_2" },
        "params": "params"
      }
    ],
    [
      "XenDisk",
      {
        "backend_type": "backend_type",
        "extra": { "field_1": "value_1", "field_2": "value_2" },
        "params": "params"
      }
    ]
  ]
}

try
    let backend = Client.attach dbg uri domain in
    ...
with Exn (Unimplemented str) -> ...

# import additional libraries if needed

class Datapath_myimplementation(Datapath_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def attach(self, dbg, uri, domain):
        """
        [attach uri domain] prepares a connection between the storage named by
        [uri] and the Xen domain with id [domain]. The return value is the
        information needed by the Xen toolstack to setup the shared-memory
        blkfront protocol. Note that the same volume may be simultaneously
        attached to multiple hosts for example over a migrate. If an
        implementation needs to perform an explicit handover, then it should
        implement [activate] and [deactivate]. This function is idempotent.
        """
        return {"implementations": [None]}
    # ...

{
  "method": "Datapath.activate",
  "params": [ { "domain": "domain", "uri": "uri", "dbg": "dbg" } ],
  "id": 33
}

try
    let () = Client.activate dbg uri domain in
    ...
with Exn (Unimplemented str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.Datapath.activate({ dbg: "string", uri: "string", domain: "string" })
    print(repr(results))

null

try
    let () = Client.activate dbg uri domain in
    ...
with Exn (Unimplemented str) -> ...

# import additional libraries if needed

class Datapath_myimplementation(Datapath_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def activate(self, dbg, uri, domain):
        """
        [activate uri domain] is called just before a VM needs to read or write
        its disk. This is an opportunity for an implementation which needs to
        perform an explicit volume handover to do it. This function is called
        in the migration downtime window so delays here will be noticeable to
        users and should be minimised. This function is idempotent.
        """
    # ...

{
  "method": "Datapath.activate_readonly",
  "params": [ { "domain": "domain", "uri": "uri", "dbg": "dbg" } ],
  "id": 34
}

try
    let () = Client.activate_readonly dbg uri domain in
    ...
with Exn (Unimplemented str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.Datapath.activate_readonly({ dbg: "string", uri: "string", domain: "string" })
    print(repr(results))

null

try
    let () = Client.activate_readonly dbg uri domain in
    ...
with Exn (Unimplemented str) -> ...

# import additional libraries if needed

class Datapath_myimplementation(Datapath_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def activate_readonly(self, dbg, uri, domain):
        """
        [activate_readonly uri domain] is called just before a VM, or the
        control domain, needs to read a volume. A single volume may be
        activated readonly multiple times, including on multiple independent
        hosts. It is not permitted for a volume to be activated both readonly
        and read-write concurrently. Implementations shall declare the
        VDI_ACTIVATE_READONLY feature for this method to be supported. Once a
        volume is activated readonly it is required that all readonly
        activations are deactivated before any read-write activation is
        attempted. This function is idempotent and in all other respects
        is interchangeable with activate.
        """
    # ...

{
  "method": "Datapath.import_activate",
  "params": [ { "domain": "domain", "uri": "uri", "dbg": "dbg" } ],
  "id": 35
}

try
    let sock_path = Client.import_activate dbg uri domain in
    ...
with Exn (Unimplemented str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.Datapath.import_activate({ dbg: "string", uri: "string", domain: "string" })
    print(repr(results))

"sock_path"

try
    let sock_path = Client.import_activate dbg uri domain in
    ...
with Exn (Unimplemented str) -> ...

# import additional libraries if needed

class Datapath_myimplementation(Datapath_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def import_activate(self, dbg, uri, domain):
        """
        [import_activate uri domain] prepares a connection to the
        storage named by [uri] for use by inbound import mirroring,
        the [domain] parameter identifies which domain to connect to,
        most likely 0 or a custom storage domain. The return value is a
        path to a UNIX domain socket to which an open file descriptor
        may be passed, by SCM_RIGHTS. This, in turn, will become
        the server end of a Network Block Device (NBD) connection
        using, new-fixed protocol. Implementations shall declare the
        VDI_MIRROR_IN feature for this method to be supported. It is
        expected that activate will have been previously called so that
        there is an active datapath.
        """
        return "string"
    # ...

{
  "method": "Datapath.deactivate",
  "params": [ { "domain": "domain", "uri": "uri", "dbg": "dbg" } ],
  "id": 36
}

try
    let () = Client.deactivate dbg uri domain in
    ...
with Exn (Unimplemented str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.Datapath.deactivate({ dbg: "string", uri: "string", domain: "string" })
    print(repr(results))

null

try
    let () = Client.deactivate dbg uri domain in
    ...
with Exn (Unimplemented str) -> ...

# import additional libraries if needed

class Datapath_myimplementation(Datapath_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def deactivate(self, dbg, uri, domain):
        """
        [deactivate uri domain] is called as soon as a VM has finished reading
        or writing its disk. This is an opportunity for an implementation which
        needs to perform an explicit volume handover to do it. This function is
        called in the migration downtime window so delays here will be
        noticeable to users and should be minimised. This function is idempotent.
        """
    # ...

{
  "method": "Datapath.detach",
  "params": [ { "domain": "domain", "uri": "uri", "dbg": "dbg" } ],
  "id": 37
}

try
    let () = Client.detach dbg uri domain in
    ...
with Exn (Unimplemented str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.Datapath.detach({ dbg: "string", uri: "string", domain: "string" })
    print(repr(results))

null

try
    let () = Client.detach dbg uri domain in
    ...
with Exn (Unimplemented str) -> ...

# import additional libraries if needed

class Datapath_myimplementation(Datapath_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def detach(self, dbg, uri, domain):
        """
        [detach uri domain] is called sometime after a VM has finished reading
        or writing its disk. This is an opportunity to clean up any resources
        associated with the disk. This function is called outside the migration
        downtime window so can be slow without affecting users. This function is
        idempotent. This function should never fail. If an implementation is
        unable to perform some cleanup right away then it should queue the
        action internally. Any error result represents a bug in the
        implementation.
        """
    # ...

{
  "method": "Datapath.close",
  "params": [ { "uri": "uri", "dbg": "dbg" } ],
  "id": 38
}

try
    let () = Client.close dbg uri in
    ...
with Exn (Unimplemented str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.Datapath.close({ dbg: "string", uri: "string" })
    print(repr(results))

null

try
    let () = Client.close dbg uri in
    ...
with Exn (Unimplemented str) -> ...

# import additional libraries if needed

class Datapath_myimplementation(Datapath_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def close(self, dbg, uri):
        """
        [close uri] is called after a disk is detached and a VM shutdown. This
        is an opportunity to throw away writes if the disk is not persistent.
        """
    # ...

{
  "method": "Data.copy",
  "params": [
    {
      "blocklist": { "ranges": [ [ 0, 0 ], [ 0, 0 ] ], "blocksize": 0 },
      "remote": "remote",
      "domain": "domain",
      "uri": "uri",
      "dbg": "dbg"
    }
  ],
  "id": 39
}

try
    let operation = Client.copy dbg uri domain remote blocklist in
    ...
with Exn (Unimplemented str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.Data.copy({ dbg: "string", uri: "string", domain: "string", remote: "string", blocklist: {"blocksize": long(0), "ranges": [[]]} })
    print(repr(results))

[ "CopyV1", "CopyV1" ]

try
    let operation = Client.copy dbg uri domain remote blocklist in
    ...
with Exn (Unimplemented str) -> ...

# import additional libraries if needed

class Data_myimplementation(Data_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def copy(self, dbg, uri, domain, remote, blocklist):
        """
        [copy uri domain remotes blocks] copies [blocks] from the local disk
        to a remote URI. This may be called as part of a Volume Mirroring
        operation, and hence may need to cooperate with whatever process is
        currently mirroring writes to ensure data integrity is maintained.
        The [remote] parameter is a remotely accessible URI, for example,
        `nbd://root:pass@foo.com/path/to/disk` that must contain all necessary
        authentication tokens
        """
        return None
    # ...

{
  "method": "Data.mirror",
  "params": [
    { "remote": "remote", "domain": "domain", "uri": "uri", "dbg": "dbg" }
  ],
  "id": 40
}

try
    let operation = Client.mirror dbg uri domain remote in
    ...
with Exn (Unimplemented str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.Data.mirror({ dbg: "string", uri: "string", domain: "string", remote: "string" })
    print(repr(results))

[ "CopyV1", "CopyV1" ]

try
    let operation = Client.mirror dbg uri domain remote in
    ...
with Exn (Unimplemented str) -> ...

# import additional libraries if needed

class Data_myimplementation(Data_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def mirror(self, dbg, uri, domain, remote):
        """
        [mirror uri domain remote] starts mirroring new writes to the volume
        to a remote URI (usually NBD). This is called as part of a volume
        mirroring process
        """
        return None
    # ...

{
  "method": "Data.stat",
  "params": [ { "operation": [ "CopyV1", "CopyV1" ], "dbg": "dbg" } ],
  "id": 41
}

try
    let status = Client.stat dbg operation in
    ...
with Exn (Unimplemented str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.Data.stat({ dbg: "string", operation: None })
    print(repr(results))

{ "progress": 0.0, "complete": true, "failed": true }

try
    let status = Client.stat dbg operation in
    ...
with Exn (Unimplemented str) -> ...

# import additional libraries if needed

class Data_myimplementation(Data_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def stat(self, dbg, operation):
        """
        [stat operation] returns the current status of [operation]. For a
        copy operation, this will contain progress information.
        """
        return {"failed": True, "complete": True, "progress": None}
    # ...

{
  "method": "Data.cancel",
  "params": [ { "operation": [ "CopyV1", "CopyV1" ], "dbg": "dbg" } ],
  "id": 42
}

try
    let () = Client.cancel dbg operation in
    ...
with Exn (Unimplemented str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.Data.cancel({ dbg: "string", operation: None })
    print(repr(results))

null

try
    let () = Client.cancel dbg operation in
    ...
with Exn (Unimplemented str) -> ...

# import additional libraries if needed

class Data_myimplementation(Data_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def cancel(self, dbg, operation):
        """
        [cancel operation] cancels a long-running operation. Note that the
        call may return before the operation has finished.
        """
    # ...

{
  "method": "Data.destroy",
  "params": [ { "operation": [ "CopyV1", "CopyV1" ], "dbg": "dbg" } ],
  "id": 43
}

try
    let () = Client.destroy dbg operation in
    ...
with Exn (Unimplemented str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.Data.destroy({ dbg: "string", operation: None })
    print(repr(results))

null

try
    let () = Client.destroy dbg operation in
    ...
with Exn (Unimplemented str) -> ...

# import additional libraries if needed

class Data_myimplementation(Data_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def destroy(self, dbg, operation):
        """
        [destroy operation] destroys the information about a long-running
        operation. This should fail when run against an operation that is
        still in progress.
        """
    # ...

{ "method": "Data.ls", "params": [ { "dbg": "dbg" } ], "id": 44 }

try
    let operations = Client.ls dbg in
    ...
with Exn (Unimplemented str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.Data.ls({ dbg: "string" })
    print(repr(results))

[ [ "CopyV1", "CopyV1" ], [ "CopyV1", "CopyV1" ] ]

try
    let operations = Client.ls dbg in
    ...
with Exn (Unimplemented str) -> ...

# import additional libraries if needed

class Data_myimplementation(Data_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def ls(self, dbg):
        """
        [ls] returns a list of all current operations
        """
        return [None]
    # ...

[ "Unimplemented", "exnt" ]

[ "Unimplemented", "exnt" ]

{ "configuration": "configuration" }

[ "Healthy", "health" ]
[ "Recovering", "health" ]
[ "Unreachable", "health" ]
[ "Unavailable", "health" ]

{
  "health": [ "Healthy", "health" ],
  "clustered": true,
  "datasources": [ "datasources" ],
  "total_space": 0,
  "free_space": 0,
  "description": "description",
  "uuid": "uuid",
  "name": "name",
  "sr": "sr"
}

{
  "extra_info": { "extra_info": "extra_info" },
  "sr": {
    "health": [ "Healthy", "health" ],
    "clustered": true,
    "datasources": [ "datasources" ],
    "total_space": 0,
    "free_space": 0,
    "description": "description",
    "uuid": "uuid",
    "name": "name",
    "sr": "sr"
  },
  "complete": true,
  "configuration": { "configuration": "configuration" }
}

[
  {
    "extra_info": { "extra_info": "extra_info" },
    "sr": {
      "health": [ "Healthy", "health" ],
      "clustered": true,
      "datasources": [ "datasources" ],
      "total_space": 0,
      "free_space": 0,
      "description": "description",
      "uuid": "uuid",
      "name": "name",
      "sr": "sr"
    },
    "complete": true,
    "configuration": { "configuration": "configuration" }
  }
]
[]

"Data"
"CBT_Metadata"
"Data_and_CBT_Metadata"

{
  "cbt_enabled": true,
  "volume_type": "Data",
  "keys": { "keys": "keys" },
  "uri": [ "uri" ],
  "physical_utilisation": 0,
  "virtual_size": 0,
  "sharable": true,
  "read_write": true,
  "description": "description",
  "name": "name",
  "uuid": "uuid",
  "key": "key"
}

[
  {
    "cbt_enabled": true,
    "volume_type": "Data",
    "keys": { "keys": "keys" },
    "uri": [ "uri" ],
    "physical_utilisation": 0,
    "virtual_size": 0,
    "sharable": true,
    "read_write": true,
    "description": "description",
    "name": "name",
    "uuid": "uuid",
    "key": "key"
  }
]
[]

"key"

{ "ranges": [ [ 0, 0 ] ], "blocksize": 0 }

[ "key_list" ]
[]

{ "bitmap": "bitmap", "granularity": 0 }

{
  "method": "SR.probe",
  "params": [
    {
      "configuration": { "field_1": "value_1", "field_2": "value_2" },
      "dbg": "dbg"
    }
  ],
  "id": 4
}

try
    let probe_result = Client.probe dbg configuration in
    ...
with Exn (Sr_not_attached str) -> ...
| Exn (SR_does_not_exist str) -> ...
| Exn (Volume_does_not_exist str) -> ...
| Exn (Unimplemented str) -> ...
| Exn (Cancelled str) -> ...
| Exn (Activated_on_another_host str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.SR.probe({ dbg: "string", configuration: {"string": "string"} })
    print(repr(results))

[
  {
    "extra_info": { "field_1": "value_1", "field_2": "value_2" },
    "sr": {
      "health": [ "Healthy", "Healthy" ],
      "clustered": true,
      "datasources": [ "datasources_1", "datasources_2" ],
      "total_space": 0,
      "free_space": 0,
      "description": "description",
      "uuid": "optional_uuid",
      "name": "name",
      "sr": "sr"
    },
    "complete": true,
    "configuration": { "field_1": "value_1", "field_2": "value_2" }
  },
  {
    "extra_info": { "field_1": "value_1", "field_2": "value_2" },
    "sr": {
      "health": [ "Healthy", "Healthy" ],
      "clustered": true,
      "datasources": [ "datasources_1", "datasources_2" ],
      "total_space": 0,
      "free_space": 0,
      "description": "description",
      "uuid": "optional_uuid",
      "name": "name",
      "sr": "sr"
    },
    "complete": true,
    "configuration": { "field_1": "value_1", "field_2": "value_2" }
  }
]

try
    let probe_result = Client.probe dbg configuration in
    ...
with Exn (Sr_not_attached str) -> ...
| Exn (SR_does_not_exist str) -> ...
| Exn (Volume_does_not_exist str) -> ...
| Exn (Unimplemented str) -> ...
| Exn (Cancelled str) -> ...
| Exn (Activated_on_another_host str) -> ...

# import additional libraries if needed

class SR_myimplementation(SR_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def probe(self, dbg, configuration):
        """
        [probe configuration]: can be used iteratively to narrow down configurations
        to use with SR.create, or to find existing SRs on the backing storage
        """
        return [{"configuration": {"string": "string"}, "complete": True, "sr": None, "extra_info": {"string": "string"}}]
    # ...

{
  "method": "SR.create",
  "params": [
    {
      "description": "description",
      "name": "name",
      "configuration": { "field_1": "value_1", "field_2": "value_2" },
      "uuid": "uuid",
      "dbg": "dbg"
    }
  ],
  "id": 5
}

try
    let configuration = Client.create dbg uuid configuration name description in
    ...
with Exn (Sr_not_attached str) -> ...
| Exn (SR_does_not_exist str) -> ...
| Exn (Volume_does_not_exist str) -> ...
| Exn (Unimplemented str) -> ...
| Exn (Cancelled str) -> ...
| Exn (Activated_on_another_host str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.SR.create({ dbg: "string", uuid: "string", configuration: {"string": "string"}, name: "string", description: "string" })
    print(repr(results))

{ "field_1": "value_1", "field_2": "value_2" }

try
    let configuration = Client.create dbg uuid configuration name description in
    ...
with Exn (Sr_not_attached str) -> ...
| Exn (SR_does_not_exist str) -> ...
| Exn (Volume_does_not_exist str) -> ...
| Exn (Unimplemented str) -> ...
| Exn (Cancelled str) -> ...
| Exn (Activated_on_another_host str) -> ...

# import additional libraries if needed

class SR_myimplementation(SR_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def create(self, dbg, uuid, configuration, name, description):
        """
        [create uuid configuration name description]: creates a fresh SR
        """
        return {"string": "string"}
    # ...

{
  "method": "SR.attach",
  "params": [
    {
      "configuration": { "field_1": "value_1", "field_2": "value_2" },
      "dbg": "dbg"
    }
  ],
  "id": 6
}

try
    let sr = Client.attach dbg configuration in
    ...
with Exn (Sr_not_attached str) -> ...
| Exn (SR_does_not_exist str) -> ...
| Exn (Volume_does_not_exist str) -> ...
| Exn (Unimplemented str) -> ...
| Exn (Cancelled str) -> ...
| Exn (Activated_on_another_host str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.SR.attach({ dbg: "string", configuration: {"string": "string"} })
    print(repr(results))

"sr"

try
    let sr = Client.attach dbg configuration in
    ...
with Exn (Sr_not_attached str) -> ...
| Exn (SR_does_not_exist str) -> ...
| Exn (Volume_does_not_exist str) -> ...
| Exn (Unimplemented str) -> ...
| Exn (Cancelled str) -> ...
| Exn (Activated_on_another_host str) -> ...

# import additional libraries if needed

class SR_myimplementation(SR_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def attach(self, dbg, configuration):
        """
        [attach configuration]: attaches the SR to the local host. Once an SR is
        attached then volumes may be manipulated.
        """
        return "string"
    # ...

{
  "method": "SR.detach",
  "params": [ { "sr": "sr", "dbg": "dbg" } ],
  "id": 7
}

try
    let () = Client.detach dbg sr in
    ...
with Exn (Sr_not_attached str) -> ...
| Exn (SR_does_not_exist str) -> ...
| Exn (Volume_does_not_exist str) -> ...
| Exn (Unimplemented str) -> ...
| Exn (Cancelled str) -> ...
| Exn (Activated_on_another_host str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.SR.detach({ dbg: "string", sr: "string" })
    print(repr(results))

null

try
    let () = Client.detach dbg sr in
    ...
with Exn (Sr_not_attached str) -> ...
| Exn (SR_does_not_exist str) -> ...
| Exn (Volume_does_not_exist str) -> ...
| Exn (Unimplemented str) -> ...
| Exn (Cancelled str) -> ...
| Exn (Activated_on_another_host str) -> ...

# import additional libraries if needed

class SR_myimplementation(SR_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def detach(self, dbg, sr):
        """
        [detach sr]: detaches the SR, clearing up any associated resources.
        Once the SR is detached then volumes may not be manipulated.
        """
    # ...

{
  "method": "SR.destroy",
  "params": [ { "sr": "sr", "dbg": "dbg" } ],
  "id": 8
}

try
    let () = Client.destroy dbg sr in
    ...
with Exn (Sr_not_attached str) -> ...
| Exn (SR_does_not_exist str) -> ...
| Exn (Volume_does_not_exist str) -> ...
| Exn (Unimplemented str) -> ...
| Exn (Cancelled str) -> ...
| Exn (Activated_on_another_host str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.SR.destroy({ dbg: "string", sr: "string" })
    print(repr(results))

null

try
    let () = Client.destroy dbg sr in
    ...
with Exn (Sr_not_attached str) -> ...
| Exn (SR_does_not_exist str) -> ...
| Exn (Volume_does_not_exist str) -> ...
| Exn (Unimplemented str) -> ...
| Exn (Cancelled str) -> ...
| Exn (Activated_on_another_host str) -> ...

# import additional libraries if needed

class SR_myimplementation(SR_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def destroy(self, dbg, sr):
        """
        [destroy sr]: destroys the [sr] and deletes any volumes associated
        with it. Note that an SR must be attached to be destroyed; otherwise
        Sr_not_attached is thrown.
        """
    # ...

{ "method": "SR.stat", "params": [ { "sr": "sr", "dbg": "dbg" } ], "id": 9 }

try
    let sr = Client.stat dbg sr in
    ...
with Exn (Sr_not_attached str) -> ...
| Exn (SR_does_not_exist str) -> ...
| Exn (Volume_does_not_exist str) -> ...
| Exn (Unimplemented str) -> ...
| Exn (Cancelled str) -> ...
| Exn (Activated_on_another_host str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.SR.stat({ dbg: "string", sr: "string" })
    print(repr(results))

{
  "health": [ "Healthy", "Healthy" ],
  "clustered": true,
  "datasources": [ "datasources_1", "datasources_2" ],
  "total_space": 0,
  "free_space": 0,
  "description": "description",
  "uuid": "optional_uuid",
  "name": "name",
  "sr": "sr"
}

try
    let sr = Client.stat dbg sr in
    ...
with Exn (Sr_not_attached str) -> ...
| Exn (SR_does_not_exist str) -> ...
| Exn (Volume_does_not_exist str) -> ...
| Exn (Unimplemented str) -> ...
| Exn (Cancelled str) -> ...
| Exn (Activated_on_another_host str) -> ...

# import additional libraries if needed

class SR_myimplementation(SR_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def stat(self, dbg, sr):
        """
        [stat sr] returns summary metadata associated with [sr]. Note this
        call does not return details of sub-volumes, see SR.ls.
        """
        return {"sr": "string", "name": "string", "uuid": None, "description": "string", "free_space": long(0), "total_space": long(0), "datasources": ["string"], "clustered": True, "health": None}
    # ...

{
  "method": "SR.set_name",
  "params": [ { "new_name": "new_name", "sr": "sr", "dbg": "dbg" } ],
  "id": 10
}

try
    let () = Client.set_name dbg sr new_name in
    ...
with Exn (Sr_not_attached str) -> ...
| Exn (SR_does_not_exist str) -> ...
| Exn (Volume_does_not_exist str) -> ...
| Exn (Unimplemented str) -> ...
| Exn (Cancelled str) -> ...
| Exn (Activated_on_another_host str) -> ...

# import necessary libraries if needed
# we assume that your library providing the client is called myclient and it provides a connect method
import myclient

if __name__ == "__main__":
    c = myclient.connect()
    results = c.SR.set_name({ dbg: "string", sr: "string", new_name: "string" })
    print(repr(results))

null

try
    let () = Client.set_name dbg sr new_name in
    ...
with Exn (Sr_not_attached str) -> ...
| Exn (SR_does_not_exist str) -> ...
| Exn (Volume_does_not_exist str) -> ...
| Exn (Unimplemented str) -> ...
| Exn (Cancelled str) -> ...
| Exn (Activated_on_another_host str) -> ...

# import additional libraries if needed

class SR_myimplementation(SR_skeleton):
    # by default each method will return a Not_implemented error
    # ...

    def set_name(self, dbg, sr, new_name):
        """
        [set_name sr new_name] changes the name of [sr]
        """
    # ...

{
  "method": "SR.set_description",
  "params": [
    { "new_description": "new_description", "sr": "sr", "dbg": "dbg" }
  ],
  "id": 11
}