/ - Diff - ganeti-local - Greek Research and Technology Network's projects

       sw.Write("return")
     class CompletionWriter:
     class CompletionWriter(object):
       """Command completion writer class.
       """

       return child_logger
     class StatusFile:
     class StatusFile(object):
       """Status file manager.
       """

         logging.info("Instance %s not running, doing nothing", iname)
         return
       class _TryShutdown:
       class _TryShutdown(object):
         def __init__(self):
           self.tried_once = False

+      }
     class _Argument:
     class _Argument(object):
       def __init__(self, min=0, max=None): # pylint: disable=W0622
         self.min = min
         self.max = max
-...
       raise errors.OpExecError(result)
     class JobPollCbBase:
     class JobPollCbBase(object):
       """Base class for L{GenericPollJob} callbacks.
       """
-...
         raise NotImplementedError()
     class JobPollReportCbBase:
     class JobPollReportCbBase(object):
       """Base class for L{GenericPollJob} reporting callbacks.
       """
-...
       return 0
     class _RunWhileClusterStoppedHelper:
     class _RunWhileClusterStoppedHelper(object):
       """Helper class for L{RunWhileClusterStopped} to simplify state management
       """
-...
       raise NotImplementedError("Can't format column type '%s'" % fdef.kind)
     class _QueryColumnFormatter:
     class _QueryColumnFormatter(object):
       """Callable class for formatting fields of a query.
       """
-...
       return constants.EXIT_SUCCESS
     class TableColumn:
     class TableColumn(object):
       """Describes a column for L{FormatTable}.
       """

       return True
     class _RunWhenNodesReachableHelper:
     class _RunWhenNodesReachableHelper(object):
       """Helper class to make shared internal state sharing easier.
       @ivar success: Indicates if all action_cb calls were successful

     from ganeti.cmdlib.common import ExpandInstanceUuidAndName
     class ResultWithJobs:
     class ResultWithJobs(object):
       """Data container for LU results with jobs.
       Instances of this class returned from L{LogicalUnit.Exec} will be recognized
-...
         raise AssertionError("PreparePostHookNodes called for NoHooksLU")
     class Tasklet:
     class Tasklet(object):
       """Tasklet base class.
       Tasklets are subcomponents for LUs. LUs can consist entirely of tasklets or
-...
         raise NotImplementedError
     class QueryBase:
     class QueryBase(object):
       """Base for query utility classes.
       """

         return ResultWithJobs(jobs, **self._ConstructPartialResult())
     class _InstNicModPrivate:
     class _InstNicModPrivate(object):
       """Data structure for network interface modifications.
       Used by L{LUInstanceSetParams}.

         self.rcvd = set()
     class ConfdClient:
     class ConfdClient(object):
       """Send queries to confd, and get back answers.
       Since the confd model works by querying multiple master candidates, and
-...
           raise errors.ConfdClientError("Invalid request type")
     class ConfdFilterCallback:
     class ConfdFilterCallback(object):
       """Callback that calls another callback, but filters duplicate results.
       @ivar consistent: a dictionary indexed by salt; for each salt, if
-...
           self._callback(up)
     class ConfdCountingCallback:
     class ConfdCountingCallback(object):
       """Callback that calls another callback, and counts the answers
       """
-...
         self._callback(up)
     class StoreResultCallback:
     class StoreResultCallback(object):
       """Callback that simply stores the most recent answer.
       @ivar _answers: dict of salt to (have_answer, reply)

                                            data['version'])
     class TemporaryReservationManager:
     class TemporaryReservationManager(object):
       """A temporary resource reservation manager.
       This is used to reserve resources in a job, before using them, making sure

           self.out_socket.send(chr(0))
     class _ShutdownCheck:
     class _ShutdownCheck(object):
       """Logic for L{Mainloop} shutdown.
       """

       return _PendingRequest(curl, req, resp_buffer.getvalue)
     class _PendingRequest:
     class _PendingRequest(object):
       def __init__(self, curl, req, resp_buffer_read):
         """Initializes this class.
-...
           req.completion_cb(req)
     class _NoOpRequestMonitor: # pylint: disable=W0232
     class _NoOpRequestMonitor(object): # pylint: disable=W0232
       """No-op request monitor.
       """
-...
       Disable = acquire
     class _PendingRequestMonitor:
     class _PendingRequestMonitor(object):
       _LOCK = "_lock"
       def __init__(self, owner, pending_fn):

     class _OpExecCallbacks(mcpu.OpExecCbBase):
       def __init__(self, queue, job, op):
         """Initializes this class.
-...
         @param op: OpCode
         """
         super(_OpExecCallbacks, self).__init__()
         assert queue, "Queue is missing"
         assert job, "Job is missing"
         assert op, "Opcode is missing"

       """
     class LockSet:
     class LockSet(object):
       """Implements a set of locks.
       This abstraction implements a set of shared locks for the same resource type,

       return utils.CommaJoin(parts)
     class ImportExportLoop:
     class ImportExportLoop(object):
       MIN_DELAY = 1.0
       MAX_DELAY = 20.0
-...
           finished_fn()
     class ExportInstanceHelper:
     class ExportInstanceHelper(object):
       def __init__(self, lu, feedback_fn, instance):
         """Initializes this class.

         return timeout
     class OpExecCbBase: # pylint: disable=W0232
     class OpExecCbBase(object): # pylint: disable=W0232
       """Base class for OpCode execution callbacks.
       """

                                    (err[0], err[2]), errors.ECODE_RESOLVER)
     class Hostname:
     class Hostname(object):
       """Class implementing resolver and hostname functionality.
       """

       return [fdef for (fdef, _, _, _) in fielddefs]
     class _FilterHints:
     class _FilterHints(object):
       """Class for filter analytics.
       When filters are used, the user of the L{Query} class usually doesn't know
-...
+        ]
     class _FilterCompilerHelper:
     class _FilterCompilerHelper(object):
       """Converts a query filter to a callable usable for filtering.
       """
-...
       return _FilterCompilerHelper(fields)(hints, qfilter)
     class Query:
     class Query(object):
       def __init__(self, fieldlist, selected, qfilter=None, namefield=None):
         """Initializes this class.
-...
+        ]
     class NodeQueryData:
     class NodeQueryData(object):
       """Data container for node data queries.
       """
-...
       return _PrepareFieldList(fields, [])
     class InstanceQueryData:
     class InstanceQueryData(object):
       """Data container for instance data queries.
       """
-...
       return _PrepareFieldList(fields, aliases)
     class LockQueryData:
     class LockQueryData(object):
       """Data container for lock data queries.
       """
-...
         ], [])
     class GroupQueryData:
     class GroupQueryData(object):
       """Data container for node group data queries.
       """
-...
+      }
     class ClusterQueryData:
     class ClusterQueryData(object):
       def __init__(self, cluster, nodes, drain_flag, watcher_pause):
         """Initializes this class.
-...
         ("name", "cluster_name")])
     class NetworkQueryData:
     class NetworkQueryData(object):
       """Data container for network data queries.
       """

     CONNECTOR = {}
     class Mapper:
     class Mapper(object):
       """Map resource to method.
       """

       return "\n".join(headers)
     class FakeCurl:
     class FakeCurl(object):
       """Fake cURL object.
       """
-...
           writefn(resp_body)
     class _RapiMock:
     class _RapiMock(object):
       """Mocking out the RAPI server parts.
       """
-...
         return (resp_msg.start_line.code, resp_msg.headers, resp_msg.body)
     class _TestLuxiTransport:
     class _TestLuxiTransport(object):
       """Mocked LUXI transport.
       Raises L{errors.RapiTestResult} for all method calls, no matter the
-...
         raise errors.RapiTestResult
     class _LuxiCallRecorder:
     class _LuxiCallRecorder(object):
       """Records all called LUXI client methods.
       """
-...
         return NotImplemented
     class InputTestClient:
     class InputTestClient(object):
       """Test version of RAPI client.
       Instances of this class can be used to test input arguments for RAPI client

         raise errors.ConfigurationError("Group '%s' not found (%s)" % (group, err))
     class GetentResolver:
     class GetentResolver(object):
       """Resolves Ganeti uids and gids by name.
       @ivar masterd_uid: The resolved uid of the masterd user

         self.server.request_workers.AddTask((self.server, message, self))
     class _MasterShutdownCheck:
     class _MasterShutdownCheck(object):
       """Logic for master daemon shutdown.
       """
-...
             self.context.jobqueue.Shutdown()
     class ClientOps:
     class ClientOps(object):
       """Class holding high-level client operations."""
       def __init__(self, server):
         self.server = server

         return serializer.DumpJson(result)
     class RapiUsers:
     class RapiUsers(object):
       def __init__(self):
         """Initializes this class.

                    for (kind, (privkey, pubkey, _)) in result))
     class SshRunner:
     class SshRunner(object):
       """Wrapper for SSH commands.
       """

       return int(round(float(value), 0))
     class _Base:
     class _Base(object):
       """Base class for storage abstraction.
       """
-...
         @param paths: List of file storage paths
         """
         super(FileStorage, self).__init__()
         self._paths = paths
       def List(self, name, fields):

           base.ThrowError("drbd%d: DRBD disk missing network info in"
                           " DisconnectNet()", self.minor)
         class _DisconnectStatus:
         class _DisconnectStatus(object):
           def __init__(self, ever_disconnected):
             self.ever_disconnected = ever_disconnected

       return detail
     class FileStatHelper:
     class FileStatHelper(object):
       """Helper to store file handle's C{fstat}.
       Useful in combination with L{ReadFile}'s C{preread} parameter.

       return ["/bin/sh", "-c", " && ".join(ShellQuoteArgs(c) for c in cmdlist)]
     class ShellWriter:
     class ShellWriter(object):
       """Helper class to write scripts with indentation.
       """
-...
       return " ".join(parts)
     class LineSplitter:
     class LineSplitter(object):
       """Splits data chunks into lines separated by newline.
       Instances provide a file-like interface.

         cli.SubmitOpCode(op, cl=cl)
     class Node:
     class Node(object):
       """Data container representing cluster node.
       """

       return GetConfig().get(name, default=default)
     class Either:
     class Either(object):
       def __init__(self, tests):
         """Initializes this class.

       """
       def __init__(self, processor):
         super(LogRecordingCallback, self).__init__()
         self.processor = processor
       def Feedback(self, *args):

       return (opts, args)
     class State:
     class State(object):
       def __init__(self, thread_count):
         """Initializes this class.

         self.glm = FakeGLM()
     class FakeGetentResolver:
     class FakeGetentResolver(object):
       """Fake runtime.GetentResolver"""
       def __init__(self):

       """
     class RapiClientFactory:
     class RapiClientFactory(object):
       """Factory class for creating RAPI clients.
       @ivar src_cluster_name: Source cluster name

Synnefo » snf-ganeti » ganeti-local

Revision 876fb142