from datetime import datetime
from mesh.standard import bind
from spire.core import Component
from spire.exceptions import TemporaryStartupError
from spire.mesh import MeshDependency, MeshServer
from spire.runtime import onstartup
from narrative import models
from narrative.bindings import platoon
from narrative.bundles import API
RecurringTask = bind(platoon, 'platoon/1.0/recurringtask')
Schedule = bind(platoon, 'platoon/1.0/schedule')
DAILY = Schedule(
id='4278895b-3b8e-4ba9-9e3c-b21c5fec58b8',
name='daily at 2am',
schedule='fixed',
anchor=datetime(2000, 1, 1, 2, 0, 0),
interval=86400)
PURGE_ENTRIES = RecurringTask(
id='426eb30a-96e2-4383-b050-3b80715fe6d1',
tag='purge-entries',
schedule_id=DAILY.id,
retry_limit=0)
class Narrative(Component):
api = MeshServer.deploy(bundles=[API], path='/')
from mesh.standard import bind
from spire.mesh import MeshDependency, ModelController, support_returning
from spire.schema import *
from spire.support.logs import LogHelper
from flux.bindings import platoon
from flux.models import Message, Request
from flux.operations import *
from flux.resources.request import Request as RequestResource
ScheduledTask = bind(platoon, 'platoon/1.0/scheduledtask')
Event = bind(platoon, 'platoon/1.0/event')
log = LogHelper('flux')
class RequestController(ModelController):
resource = RequestResource
version = (1, 0)
model = Request
mapping = (
'id name status originator assignee creator '
'slot_order claimed completed'
)
schema = SchemaDependency('flux')
docket_entity = MeshDependency('docket.entity')
flux = MeshDependency('flux')
platoon = MeshDependency('platoon')
@support_returning
def create(self, request, response, subject, data):
from spire.core import Component, Dependency
from spire.mesh import MeshClient, MeshDependency, MeshServer
from spire.runtime import onstartup
from keg.bindings import platoon, tap
from keg.bundles import API
from keg import models
from tap.security import middleware
from spire.schema import SchemaDependency
from spire.support.logs import LogHelper
log = LogHelper('keg')
RecurringTask = bind(platoon, 'platoon/1.0/recurringtask')
ResourceRegistry = bind(tap, 'tap/1.0/resourceregistry')
Schedule = bind(platoon, 'platoon/1.0/schedule')
RESOURCE_REGISTRIES = {
'beer': models.Beer.id,
'brewery': models.Brewery.id,
'pob': models.Pob.id,
'tab': models.Tab.id,
}
class ContextMeshServer(MeshServer):
context_middleware = ContextMiddleware([HeaderParser()])
class PermissionMeshClient(MeshServer):
# TODO: specify permission here or higher in the chain
from mesh.standard import bind
from scheme import current_timestamp
from spire.mesh import MeshDependency, ModelController, support_returning
from spire.schema import NoResultFound, SchemaDependency
from flux.bindings import platoon, truss
from flux.engine.queue import QueueManager
from flux.models import *
from flux.resources import Run as RunResource
Message = bind(truss, 'truss/1.0/message')
ScheduledTask = bind(platoon, 'platoon/1.0/scheduledtask')
SubscribedTask = bind(platoon, 'platoon/1.0/subscribedtask')
class RunController(ModelController):
resource = RunResource
version = (1, 0)
model = Run
mapping = 'id workflow_id name status parameters started ended'
schema = SchemaDependency('flux')
flux = MeshDependency('flux')
platoon = MeshDependency('platoon')
@support_returning
def create(self, request, response, subject, data):
session = self.schema.session
subject = self.model.create(session, **data)
from spire.exceptions import TemporaryStartupError
from spire.mesh import MeshDependency, MeshServer
from spire.runtime import current_runtime, onstartup
from spire.schema import Schema, SchemaDependency
from docket import models
from docket.bindings import platoon
from docket.bundles import BUNDLES
from docket.engine.archetype_registry import ArchetypeRegistry
from docket.engine.registry import EntityRegistry
from docket.resources import *
schema = Schema('docket')
RecurringTask = bind(platoon, 'platoon/1.0/recurringtask')
Schedule = bind(platoon, 'platoon/1.0/schedule')
EVERY_SIX_HOURS = Schedule(id='c53628ff-7b48-4f60-ba56-bea431fc7da2',
name='every six hours',
schedule='fixed',
anchor=datetime(2000, 1, 1, 0, 0, 0),
interval=21600)
SYNC_ALL_ENTITIES = RecurringTask(id='7d715e10-0f00-476d-ace1-dc896d7da3e5',
tag='synchronize-all-entities',
schedule_id=EVERY_SIX_HOURS.id,
retry_limit=0)
class Docket(Component):
from mesh.standard import bind
from spire.core import Dependency
from spire.mesh import MeshDependency
from spire.schema import *
from spire.support.logs import LogHelper
from docket.bindings import platoon
from docket.controllers.entity import BaseEntityController
from docket.engine.registry import EntityRegistry
from docket.models import *
from docket.resources.package import Package as PackageResource
log = LogHelper('docket')
ScheduledTask = bind(platoon, 'platoon/1.0/scheduledtask')
class PackageController(BaseEntityController):
resource = PackageResource
version = (1, 0)
model = Package
registry = Dependency(EntityRegistry)
schema = SchemaDependency('docket')
docket = MeshDependency('docket')
mapping = 'id name designation description created modified package status'
def create(self, request, response, subject, data):
session = self.schema.session
subject = self.model.create(session, **data)
log('info', 'create request for package %s', subject.id)
def register(self):
bind('flux.API', 'flux/1.0/operation')(**self.operation).put()
return self.id, self.flux.prepare(*self.endpoint,
preparation={'type': 'http'})
def register(self):
bind('flux.API', 'flux/1.0/operation')(**self.operation).put()
return self.id, self.flux.prepare(*self.endpoint, preparation={'type': 'http'})
from spire.core import Unit
from spire.mesh import Surrogate, MeshDependency
from spire.schema import *
from spire.support.logs import LogHelper
from sqlalchemy.orm.collections import attribute_mapped_collection
from flux.bindings import truss, platoon
from flux.constants import *
from flux.models import EmailTemplate
__all__ = ('Request', 'RequestAttachment', 'RequestSlot', 'RequestProduct')
schema = Schema('flux')
log = LogHelper('flux')
ExternalUrl = bind(truss, 'truss/1.0/externalurl')
Msg = bind(truss, 'truss/1.0/message')
SlotTypes = {
'text': (scheme.Text, {
'type': 'textbox'
}),
'textarea': (scheme.Text, {
'type': 'textbox',
'options': {
'multiline': True
}
}),
}
Event = bind(platoon, 'platoon/1.0/event')
from mesh.standard import OperationError, bind
from scheme import current_timestamp
from spire.schema import *
from spire.support.logs import LogHelper
from flux.bindings import platoon
from flux.constants import *
from flux.models.execution import WorkflowExecution
from flux.models.workflow import Workflow
__all__ = ("Run",)
Event = bind(platoon, "platoon/1.0/event")
schema = Schema("flux")
log = LogHelper("flux")
class Run(Model):
"""A workflow run."""
class meta:
schema = schema
tablename = "run"
id = Identifier()
workflow_id = ForeignKey("workflow.id", nullable=False)
name = Text(nullable=False)
status = Enumeration(RUN_STATUSES, nullable=False, default="pending")
parameters = Json()
started = DateTime(timezone=True)
from mesh.standard import bind
from spire.core import Unit
from spire.mesh import MeshDependency
from flux.bindings import docket, platoon
from flux.support.operation import *
__all__ = ('Operation', 'ScheduledTask', 'SubscribedTask')
Process = bind(platoon, 'platoon/1.0/process')
ScheduledTask = bind(platoon, 'platoon/1.0/scheduledtask')
SubscribedTask = bind(platoon, 'platoon/1.0/subscribedtask')
class Operation(Unit, OperationMixin):
"""A workflow operation."""
docket = MeshDependency('docket')
docket_entity = MeshDependency('docket.entity')
flux = MeshDependency('flux')
platoon = MeshDependency('platoon')
process = Process
id = None
endpoint = None
def register(self):
bind('flux.API', 'flux/1.0/operation')(**self.operation).put()
return self.id, self.flux.prepare(*self.endpoint, preparation={'type': 'http'})
from mesh.standard import bind
from spire.core import Component, Dependency
from spire.mesh import MeshDependency, MeshServer
from spire.runtime import onstartup
import flux.models
from flux.bindings import docket, platoon
from flux.bundles import API
from flux.operations import OPERATIONS
from flux.resources import *
Executor = bind(platoon, "platoon/1.0/executor")
Intent = bind(docket, "docket/1.0/intent")
Registration = bind(docket, "docket/1.0/registration")
ENTITY_REGISTRATIONS = [
Registration(id="flux:workflow", name="workflow", title="Workflow", specification=API.describe(["workflow"])),
Registration(
id="flux:run",
name="run",
title="Run",
specification=API.describe(["run"]),
change_event="run:changed",
cached_attributes={"status": {"type": "text"}},
),
]
GENERATED_BY = Intent(id="generated-by", name="Generated by", exclusive=True)
class Flux(Component):
from spire.core import Unit
from spire.mesh import Surrogate, MeshDependency
from spire.schema import *
from spire.support.logs import LogHelper
from sqlalchemy.orm.collections import attribute_mapped_collection
from flux.bindings import truss, platoon
from flux.constants import *
from flux.models import EmailTemplate
__all__ = ('Request', 'RequestAttachment', 'RequestSlot', 'RequestProduct')
schema = Schema('flux')
log = LogHelper('flux')
ExternalUrl = bind(truss, 'truss/1.0/externalurl')
Msg = bind(truss, 'truss/1.0/message')
SlotTypes = {
'text': (scheme.Text, {'type': 'textbox'}),
'textarea': (scheme.Text, {'type': 'textbox', 'options': {'multiline': True}}),
}
Event = bind(platoon, 'platoon/1.0/event')
class Request(Model):
"""An request."""
class meta:
schema = schema
tablename = 'request'
from mesh.standard import bind
from spire.core import Unit
from spire.mesh import MeshDependency
from spire.schema import SchemaDependency
from flux.bindings import platoon
from flux.models import Operation
Process = bind(platoon, 'platoon/1.0/process')
Queue = bind(platoon, 'platoon/1.0/queue')
class QueueManager(Unit):
"""The queue manager."""
flux = MeshDependency('flux')
platoon = MeshDependency('platoon')
schema = SchemaDependency('flux')
def bootstrap(self):
session = self.schema.session
for operation in session.query(Operation):
self._register_queue(operation)
def initiate(self, operation, tag, input=None, id=None, timeout=None):
params = {'queue_id': operation.queue_id, 'tag': tag}
if id is not None:
params['id'] = id
if input is not None:
params['input'] = input
if timeout is not None:
from mesh.standard import bind
from spire.core import Component, Dependency
from spire.mesh import MeshDependency, MeshServer
from spire.runtime import onstartup
import flux.models
from flux.bindings import docket, platoon
from flux.bundles import API
from flux.operations import OPERATIONS
from flux.resources import *
Executor = bind(platoon, 'platoon/1.0/executor')
Intent = bind(docket, 'docket/1.0/intent')
Registration = bind(docket, 'docket/1.0/registration')
SubscribedTask = bind(platoon, 'platoon/1.0/subscribedtask')
ENTITY_REGISTRATIONS = [
Registration(
id='flux:workflow',
name='workflow',
title='Workflow',
specification=API.describe(['workflow']),
cached_attributes={
'is_service': {'type': 'boolean'},
'type': {'type': 'text'},
},
),
Registration(
id='flux:run',
name='run',
title='Run',
from mesh.standard import bind
from scheme import current_timestamp
from spire.mesh import MeshDependency, ModelController, support_returning
from spire.schema import NoResultFound, SchemaDependency
from flux.bindings import platoon, truss
from flux.engine.queue import QueueManager
from flux.models import *
from flux.resources import Run as RunResource
Message = bind(truss, 'truss/1.0/message')
ScheduledTask = bind(platoon, 'platoon/1.0/scheduledtask')
SubscribedTask = bind(platoon, 'platoon/1.0/subscribedtask')
class RunController(ModelController):
resource = RunResource
version = (1, 0)
model = Run
mapping = 'id workflow_id name status parameters started ended'
schema = SchemaDependency('flux')
flux = MeshDependency('flux')
platoon = MeshDependency('platoon')
@support_returning
def create(self, request, response, subject, data):
session = self.schema.session
subject = self.model.create(session, **data)
session.commit()
from spire.mesh import MeshDependency, ModelController, support_returning
from spire.schema import SchemaDependency, IntegrityError
from spire.support.logs import LogHelper
from spire.wsgi.upload import UploadManager
from flux.bindings import truss, platoon
from flux.constants import *
from flux.models import *
from flux.resources import Workflow as WorkflowResource
from flux.engine.workflow import Workflow as WorkflowEngine
import urllib2
import json
log = LogHelper('flux')
Event = bind(platoon, 'platoon/1.0/event')
ExternalUrl = bind(truss, 'truss/1.0/externalurl')
class WorkflowController(ModelController):
resource = WorkflowResource
version = (1, 0)
model = Workflow
mapping = 'id name designation is_service specification modified type'
schema = SchemaDependency('flux')
uploads = Dependency(UploadManager)
flux = MeshDependency('flux')
docket_entity = MeshDependency('docket.entity')
@support_returning
from mesh.standard import bind
from spire.core import Unit
from spire.mesh import MeshDependency
from spire.schema import SchemaDependency
from flux.bindings import platoon
from flux.models import Operation
Process = bind(platoon, 'platoon/1.0/process')
Queue = bind(platoon, 'platoon/1.0/queue')
class QueueManager(Unit):
"""The queue manager."""
flux = MeshDependency('flux')
platoon = MeshDependency('platoon')
schema = SchemaDependency('flux')
def bootstrap(self):
session = self.schema.session
for operation in session.query(Operation):
self._register_queue(operation)
def initiate(self, operation, tag, input=None, id=None, timeout=None):
params = {'queue_id': operation.queue_id, 'tag': tag}
if id is not None:
params['id'] = id
if input is not None:
params['input'] = input
if timeout is not None:
params['timeout'] = timeout
from mesh.standard import bind
from spire.core import Unit
from spire.mesh import MeshDependency
from flux.bindings import docket, platoon
from flux.support.operation import *
__all__ = ('Operation', 'ScheduledTask', 'SubscribedTask')
Process = bind(platoon, 'platoon/1.0/process')
ScheduledTask = bind(platoon, 'platoon/1.0/scheduledtask')
SubscribedTask = bind(platoon, 'platoon/1.0/subscribedtask')
class Operation(Unit, OperationMixin):
"""A workflow operation."""
docket = MeshDependency('docket')
docket_entity = MeshDependency('docket.entity')
flux = MeshDependency('flux')
platoon = MeshDependency('platoon')
process = Process
id = None
endpoint = None
def register(self):
bind('flux.API', 'flux/1.0/operation')(**self.operation).put()
return self.id, self.flux.prepare(*self.endpoint,
preparation={'type': 'http'})
from mesh.exceptions import GoneError
from mesh.standard import bind
from scheme import current_timestamp
from spire.schema import *
from spire.support.logs import LogHelper
from flux.bindings import platoon
from flux.constants import *
__all__ = ('WorkflowExecution', )
log = LogHelper('flux')
schema = Schema('flux')
Process = bind(platoon, 'platoon/1.0/process')
class WorkflowExecution(Model):
"""A step execution."""
class meta:
constraints = [UniqueConstraint('run_id', 'execution_id')]
schema = schema
tablename = 'execution'
id = Identifier()
run_id = ForeignKey('run.id', nullable=False, ondelete='CASCADE')
execution_id = Integer(minimum=1, nullable=False)
ancestor_id = ForeignKey('execution.id')
step = Token(nullable=False)
name = Text()
status = Enumeration(RUN_STATUSES, nullable=False, default='pending')
from mesh.standard import bind, OperationError, ValidationError
from scheme import current_timestamp
from spire.mesh import Surrogate
from spire.schema import *
from spire.support.logs import LogHelper
from sqlalchemy.orm.collections import attribute_mapped_collection
from flux.bindings import platoon
from flux.constants import *
from flux.models.execution import WorkflowExecution
from flux.models.workflow import Workflow
__all__ = ('Product', 'Run')
Event = bind(platoon, 'platoon/1.0/event')
schema = Schema('flux')
log = LogHelper('flux')
class Product(Model):
"""A workflow product."""
class meta:
constraints = [UniqueConstraint('run_id', 'token')]
schema = schema
tablename = 'product'
id = Identifier()
run_id = ForeignKey('run.id', nullable=False, ondelete='CASCADE')
token = Token(nullable=False)
product = Surrogate(nullable=False)
from mesh.standard import bind
from spire.core import Component, Dependency
from spire.mesh import MeshDependency, MeshServer
from spire.runtime import onstartup
import flux.models
from flux.bindings import docket, platoon
from flux.bundles import API
from flux.operations import OPERATIONS
from flux.resources import *
Executor = bind(platoon, 'platoon/1.0/executor')
Intent = bind(docket, 'docket/1.0/intent')
Registration = bind(docket, 'docket/1.0/registration')
ENTITY_REGISTRATIONS = [
Registration(
id='flux:workflow',
name='workflow',
title='Workflow',
specification=API.describe(['workflow']),
),
Registration(
id='flux:run',
name='run',
title='Run',
specification=API.describe(['run']),
change_event='run:changed',
cached_attributes={
'status': {'type': 'text'},
},
from mesh.standard import bind
from spire.mesh import Definition, MeshDependency
from spire.schema import *
from sqlalchemy.orm.collections import attribute_mapped_collection
from flux.bindings import platoon
from flux.constants import *
schema = Schema('flux')
Process = bind(platoon, 'platoon/1.0/process')
class Operation(Model):
"""A workflow operation."""
class meta:
schema = schema
tablename = 'operation'
id = Token(segments=2, nullable=False, primary_key=True)
name = Text(nullable=False)
phase = Enumeration(OPERATION_PHASES, nullable=False)
description = Text()
schema = Definition()
parameters = Json()
outcomes = relationship('Outcome', backref='operation',
collection_class=attribute_mapped_collection('name'),
cascade='all,delete-orphan', passive_deletes=True)
@property
from mesh.standard import bind
from spire.core import Component, Dependency
from spire.mesh import MeshDependency, MeshServer
from spire.runtime import onstartup
import flux.models
from flux.bindings import docket, platoon
from flux.bundles import API
from flux.operations import OPERATIONS
from flux.resources import *
Executor = bind(platoon, "platoon/1.0/executor")
Intent = bind(docket, "docket/1.0/intent")
Registration = bind(docket, "docket/1.0/registration")
SubscribedTask = bind(platoon, "platoon/1.0/subscribedtask")
ENTITY_REGISTRATIONS = [
Registration(
id="flux:workflow",
name="workflow",
title="Workflow",
specification=API.describe(["workflow"]),
cached_attributes={"is_service": {"type": "boolean"}, "type": {"type": "text"}},
),
Registration(
id="flux:run",
name="run",
title="Run",
specification=API.describe(["run"]),
change_event="run:changed",
cached_attributes={"status": {"type": "text"}},
from spire.mesh import MeshDependency, ModelController, support_returning
from spire.schema import SchemaDependency, IntegrityError
from spire.support.logs import LogHelper
from spire.wsgi.upload import UploadManager
from flux.bindings import truss, platoon
from flux.constants import *
from flux.models import *
from flux.resources import Workflow as WorkflowResource
from flux.engine.workflow import Workflow as WorkflowEngine
import urllib2
import json
log = LogHelper('flux')
Event = bind(platoon, 'platoon/1.0/event')
ExternalUrl = bind(truss, 'truss/1.0/externalurl')
class WorkflowController(ModelController):
resource = WorkflowResource
version = (1, 0)
model = Workflow
mapping = 'id name designation is_service specification modified type'
schema = SchemaDependency('flux')
uploads = Dependency(UploadManager)
flux = MeshDependency('flux')
docket_entity = MeshDependency('docket.entity')
@support_returning
def create(self, request, response, subject, data):
from mesh.standard import bind
from spire.core import Dependency
from spire.mesh import MeshDependency
from spire.schema import *
from spire.support.logs import LogHelper
from docket.bindings import platoon
from docket.controllers.entity import BaseEntityController
from docket.engine.registry import EntityRegistry
from docket.models import *
from docket.resources.package import Package as PackageResource
log = LogHelper('docket')
ScheduledTask = bind(platoon, 'platoon/1.0/scheduledtask')
class PackageController(BaseEntityController):
resource = PackageResource
version = (1, 0)
model = Package
registry = Dependency(EntityRegistry)
schema = SchemaDependency('docket')
docket = MeshDependency('docket')
mapping = 'id name designation description created modified package status'
def create(self, request, response, subject, data):
session = self.schema.session
subject = self.model.create(session, **data)
from mesh.standard import bind
from spire.core import Component, Dependency
from spire.mesh import MeshDependency, MeshServer
from spire.runtime import onstartup
import flux.models
from flux.bindings import docket, platoon
from flux.bundles import API
from flux.operations import OPERATIONS
from flux.resources import *
Executor = bind(platoon, 'platoon/1.0/executor')
Intent = bind(docket, 'docket/1.0/intent')
Registration = bind(docket, 'docket/1.0/registration')
SubscribedTask = bind(platoon, 'platoon/1.0/subscribedtask')
ENTITY_REGISTRATIONS = [
Registration(
id='flux:workflow',
name='workflow',
title='Workflow',
specification=API.describe(['workflow']),
cached_attributes={
'is_service': {
'type': 'boolean'
},
'type': {
'type': 'text'
},
},
),
def register(self):
from flux.bundles import API
Operation = bind(API, 'flux/1.0/operation')
Operation(**self.operation).put()
return self.id, self.flux.prepare(*self.endpoint, preparation={'type': 'http'})
