Synnefo » snf-ganeti

            case jids of

              Bad x -> return $ Bad x

              Ok x -> do

                waitForJobs client x

         )

  case jrs of

  ) where

import Data.IORef

import Control.Monad

import Text.JSON (encodeStrict, decodeStrict)

import qualified Text.JSON as J

-- * Generic protocol functionality

-- | The Ganeti job type.

$(declareSADT "QrViaLuxi"

  [ ("QRLock", 'qrLock)

     , ("lock",   [t| Bool     |], [| id |])

     ])

  , (luxiReqQueryJobs,

     , ("fields", [t| [String] |], [| id |])

     ])

  , (luxiReqQueryExports,

     [ ("ops", [t| [[OpCode]] |], [| id |]) ]

    )

  , (luxiReqWaitForJobChange,

     , ("fields",   [t| [String]|], [| id |])

     , ("prev_job", [t| JSValue |], [| id |])

     , ("prev_log", [t| JSValue |], [| id |])

     , ("tmout",    [t| Int     |], [| id |])

     ])

  , (luxiReqArchiveJob,

    )

  , (luxiReqAutoArchiveJobs,

     [ ("age",   [t| Int |], [| id |])

     , ("tmout", [t| Int |], [| id |])

     ])

  , (luxiReqCancelJob,

    )

  , (luxiReqSetDrainFlag,

     [ ("flag", [t| Bool |], [| id |]) ]

  case call of

    ReqQueryJobs -> do

              (jid, jargs) <- fromJVal args

              let rargs = map fromJSString jargs

              return $ QueryJobs rid rargs

    ReqQueryInstances -> do

                    J.readJSON d `ap`

                    J.readJSON e

                  _ -> J.Error "Not enough values"

              return $ WaitForJobChange rid fields pinfo pidx wtmout

    ReqArchiveJob -> do

              [jid] <- fromJVal args

              return $ ArchiveJob rid

    ReqAutoArchiveJobs -> do

              (age, tmout) <- fromJVal args

              return $ QueryTags kind name

    ReqCancelJob -> do

              [job] <- fromJVal args

              return $ CancelJob rid

    ReqSetDrainFlag -> do

              [flag] <- fromJVal args

-- | Parses a job ID.

parseJobId :: JSValue -> Result JobId

parseJobId x = Bad $ "Wrong type/value for job id: " ++ show x

-- | Parse job submission result.

-- | Custom queryJobs call.

queryJobsStatus :: Client -> [JobId] -> IO (Result [JobStatus])

queryJobsStatus s jids = do

  return $ case rval of

             Bad x -> Bad x

             Ok y -> case J.readJSON y::(J.Result [[JobStatus]]) of

    result = cl.SubmitManyJobs(jobs)

    if not (len(result) == 2 and

            compat.all(len(i) == 2 for i in result) and

            result[0][0] and not result[1][0]):

      raise errors.OpExecError("Submitting multiple jobs did not work as"

                               " expected, result %s" % result)

#

#

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

    raise errors.ProgrammerError("Unknown job status code '%s'" % value)

def ListJobs(opts, args):

  """List the jobs

                     opts.separator, not opts.no_headers,

                     format_override=fmtoverride, verbose=opts.verbose,

                     force_filter=opts.force_filter, namefield="id",

def ListJobFields(opts, args):

    "opstart", "opexec", "opend", "received_ts", "start_ts", "end_ts",

    ]

  first = True

#

#

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

      raise errors.GenericError("A job needs at least one opcode")

    self.queue = queue

    self.ops = [_QueuedOpCode(op) for op in ops]

    self.log_serial = 0

    self.received_timestamp = TimeStampNow()

    """

    obj = _QueuedJob.__new__(cls)

    obj.queue = queue

    obj.received_timestamp = state.get("received_timestamp", None)

    obj.start_timestamp = state.get("start_timestamp", None)

    obj.end_timestamp = state.get("end_timestamp", None)

    @type job: L{_QueuedJob}

    @param job: Job object

    @param dep_job_id: ID of dependency job

    @type dep_status: list

    @param dep_status: Required status

    """

    assert ht.TListOf(ht.TElemOf(constants.JOBS_FINALIZED))(dep_status)

    if job.id == dep_job_id:

    @attention: Do not call until L{CheckAndRegister} returned a status other

      than C{WAITDEP} for C{job_id}, or behaviour is undefined

    @param job_id: Job ID

    """

    self._lock.acquire()

    try:

    @type count: integer

    @param count: how many serials to return

    """

    assert ht.TPositiveInt(count)

    for filename in utils.ListVisibleFiles(constants.QUEUE_DIR):

      m = constants.JOB_FILE_RE.match(filename)

      if m:

    if sort:

    return jlist

  def _LoadJobUnlocked(self, job_id):

    existing, or try to load the job from the disk. If loading from

    disk, it will also add the job to the cache.

    @param job_id: the job id

    @rtype: L{_QueuedJob} or None

    @return: either None or the job object

    Given a job file, read, load and restore it in a _QueuedJob format.

    @param job_id: job identifier

    @type try_archived: bool

    @param try_archived: Whether to try loading an archived job

    In case of error reading the job, it gets returned as None, and the

    exception is logged.

    @param job_id: job identifier

    @type try_archived: bool

    @param try_archived: Whether to try loading an archived job

  def _GetJobStatusForDependencies(self, job_id):

    """Gets the status of a job for dependencies.

    @param job_id: Job ID

    @raise errors.JobLost: If job can't be found

    """

    # Not using in-memory cache as doing so would require an exclusive lock

    # Try to load from disk

                        timeout):

    """Waits for changes in a job.

    @param job_id: Job identifier

    @type fields: list of strings

    @param fields: Which fields to check for changes

    This will only succeed if the job has not started yet.

    @param job_id: job ID of job to be cancelled.

    """

    This is just a wrapper over L{_ArchiveJobsUnlocked}.

    @param job_id: Job ID of job to be archived.

    @rtype: bool

    @return: Whether job was archived

    @param qfilter: Query filter

    """

  def OldStyleQueryJobs(self, job_ids, fields):

    """Returns a list of jobs in queue.

        the requested fields

    """

    qfilter = qlang.MakeSimpleFilter("id", job_ids)

  @locking.ssynchronized(_LOCK)

  def PrepareShutdown(self):

#

#

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

def FormatJobID(job_id):

  @type job_id: int or long

  @param job_id: the numeric job id

  @return: the formatted job id

  """

  if job_id < 0:

    raise errors.ProgrammerError("Job ID %s is negative" % job_id)

def GetArchiveDirectory(job_id):

    try:

      number = int(text)

    except (TypeError, ValueError), err:

                                 errors.ECODE_INVAL)

    return [OP_EQUAL, namefield, number]

  elif _CheckGlobbing(text):

        (status, name) = _ProcessResult(self._name_fn(ctx, item))

        assert status == constants.RS_NORMAL

        # TODO: Are there cases where we wouldn't want to use NiceSort?

        result.append((utils.NiceSortKey(name), idx, row))

      else:

        result.append(row)

  """

  fields = [

     None, QFF_JOB_ID, lambda _, (job_id, job): job_id),

    (_MakeField("status", "Status", QFT_TEXT, "Job status"),

     None, 0, _JobUnavail(lambda job: job.CalcStatus())),

def _VerifyReturnsJob(data):

def TestVersion():

#!/usr/bin/python

#

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

      # Check job status

      self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_ERROR)

      self.assertEqual(job.GetInfo(["status"]), [constants.JOB_STATUS_ERROR])

      # Check opcode status

           for i in range(3)]

    # Create job

    job = self._CreateJob(queue, job_id, ops)

    self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_QUEUED)

class TestFormatJobID(testutils.GanetiTestCase):

  def test(self):

    self.assertEqual(jstore.FormatJobID(319472592764518609),

  def testErrors(self):

    for i in [-1, -2288, -9667, -0.205641, 0.0, 0.1, 13041.4472, "", "Hello",

    for (what, fielddefs) in query.ALL_FIELDS.items():

      if what == constants.QR_JOB:

        namefield = "id"

      else:

      assert namefield in fielddefs

    for (what, fielddefs) in query.ALL_FIELDS.items():

      if what == constants.QR_JOB:

        namefield = "id"

      elif what == constants.QR_EXPORT:

        namefield = "export"

      else:

        namefield = "name"

      checks = [

        [], ["="], ["=", "foo"], ["unknownop"], ["!"],