def __init__(self, classobj):
self._class = misc.getCallableByName(classobj)
self._bases = self._class.__bases__
self.doc = self._class.__doc__
self._attrs = {}
self._methods = {}
self._properties = {}
sourcelines = inspect.getsourcelines(self._class)
startline = sourcelines[1]
endline = startline + len(sourcelines[0]) - 1
self.boundaries = (startline, endline)
self._instance = self._class()
for prop in self._class.__slots__:
self._attrs[prop] = getattr(self._instance, prop)
for member_name in self._class.__dict__:
member = self._class.__dict__[member_name]
if type(member) == types.FunctionType:
self._methods[member_name] = member
elif type(member) == property:
self._properties[member_name] = member
self._module = sys.modules[self._class.__module__]
self._newimports = []
self._imports = {}
moduledict = self._module.__dict__
for x in moduledict:
if type(moduledict[x]) == types.ModuleType:
self._imports[moduledict[x]] = x
elif callable(moduledict[x]) and (sys.modules[moduledict[x].__module__] != self._module):
imported = misc.getCallableByName(moduledict[x].__module__ + "." + x)
self._imports[imported] = x
def commitChanges(self):
GenericSchemaEditor.commitChanges(self)
if len(self._addedProps):
# we must reload the class module
oMod = misc.getCallableByName(self._class.__module__)
reload(oMod)
from porcupine.oql.command import OqlCommand
db = offlinedb.getHandle()
oql_command = OqlCommand()
rs = oql_command.execute("select * from deep('/') where instanceof('%s')" % self._instance.contentclass)
try:
if len(rs):
txn = offlinedb.OfflineTransaction()
try:
for item in rs:
for name in self._addedProps:
if not hasattr(item, name):
setattr(item, name, self._addedProps[name])
db.putItem(item, txn)
txn.commit()
except Exception, e:
txn.abort()
raise e
sys.exit(2)
finally:
offlinedb.close()
def new(self):
"Displays a generic form for creating a new object"
context = HttpContext.current()
sCC = context.request.queryString['cc'][0]
oNewItem = misc.getCallableByName(sCC)()
params = {
'CC': sCC,
'URI': context.request.getRootUrl() + '/' + self.id,
'ICON': oNewItem.__image__,
'PROPERTIES_TAB': '',
'EXTRA_TABS': '',
'SECURITY_TAB': baseitem._getSecurity(self, context.user, True)
}
# inspect item properties
sProperties = ''
for attr_name in oNewItem.__props__:
attr = getattr(oNewItem, attr_name)
if isinstance(attr, datatypes.DataType):
control, tab = baseitem._getControlFromAttribute(oNewItem,
attr_name,
attr,
False,
True)
sProperties += control
params['EXTRA_TABS'] += tab
params['PROPERTIES'] = sProperties
return params
def setParams(self):
self.response.setHeader('cache-control', 'no-cache')
self.response.setExpiration(1200)
sCC = self.request.queryString['cc'][0]
oNewItem = misc.getCallableByName(sCC)()
self.params = {
'CC': sCC,
'URI': self.request.getRootUrl() + '/' + self.item.id,
'ICON': oNewItem.__image__,
'PROPERTIES_TAB': '',
'EXTRA_TABS': '',
'SECURITY_TAB': self.getSecurity(self.item, True)
}
# inspect item properties
sProperties = ''
for attr_name in oNewItem.__props__:
attr = getattr(oNewItem, attr_name)
if isinstance(attr, datatypes.DataType):
control, tab = \
self.getControlFromAttribute(attr_name, attr, False, True)
sProperties += control
self.params['EXTRA_TABS'] += tab
self.params['PROPERTIES_TAB'] = \
'<tab caption="@@PROPERTIES@@">%s</tab>' % sProperties
def getInfo(self):
sLang = self.request.getLang()
lstChildren = []
children = self.item.getChildren()
for child in children:
obj = {
'id' : child.id,
'image': child.__image__,
'displayName' : child.displayName.value,
'isCollection': child.isCollection,
'modified': date.Date(child.modified)
}
if hasattr(child, 'size'):
obj['size'] = child.size
lstChildren.append(obj)
containment = []
for contained in self.item.containment:
image = misc.getCallableByName(contained).__image__
if not type(image)==str:
image = ''
localestring = resources.getResource(contained, sLang)
containment.append( [localestring, contained, image] )
return {
'displayName': self.item.displayName.value,
'path': misc.getFullPath(self.item),
'parentid': self.item.parentid,
'iscollection': self.item.isCollection,
'containment': containment,
'user_role': objectAccess.getAccess(self.item, self.session.user),
'contents': lstChildren
}
def create(self, data):
# create new item
oNewItem = misc.getCallableByName(data.pop('CC'))()
# get user role
iUserRole = objectAccess.getAccess(self.item, self.session.user)
if data.has_key('__rolesinherited') and iUserRole == objectAccess.COORDINATOR:
oNewItem.inheritRoles = data.pop('__rolesinherited')
if not oNewItem.inheritRoles:
acl = data.pop('__acl')
if acl:
security = {}
for descriptor in acl:
security[descriptor['id']] = int(descriptor['role'])
oNewItem.security = security
# set props
for prop in data:
oAttr = getattr(oNewItem, prop)
if isinstance(oAttr, datatypes.File):
if data[prop]['tempfile']:
oAttr.filename = data[prop]['filename']
sPath = self.server.temp_folder + '/' + data[prop]['tempfile']
oAttr.loadFromFile(sPath)
os.remove(sPath)
elif isinstance(oAttr, datatypes.Date):
oAttr.value = data[prop].value
else:
oAttr.value = data[prop]
txn = self.server.store.getTransaction()
oNewItem.appendTo(self.item.id, txn)
txn.commit()
return True
def start(self):
try:
# read configuration file
from porcupine.config.settings import settings
# initialize logging
log.initialize_logging()
self.logger.info('Server starting...')
# register request interfaces
for key, value in settings['requestinterfaces'].items():
settings['requestinterfaces'][key] = \
misc.getCallableByName(value)
self.logger.info('Succesfullly registered %i request interfaces' % \
len(settings['requestinterfaces']))
# register template languages
for key, value in settings['templatelanguages'].items():
settings['templatelanguages'][key] = \
misc.getCallableByName(value)
self.logger.info('Succesfullly registered %i template languages' % \
len(settings['templatelanguages']))
# load published directories
self.logger.info('Loading published directories\' registrations...')
from porcupine.config import pubdirs
# open database
self.logger.info('Opening database...')
_db.open(misc.getCallableByName(
settings['store']['interface']))
# create session manager
self.logger.info('Creating session manager...')
SessionManager.open(misc.getCallableByName(
settings['sessionmanager']['interface']),
int(settings['sessionmanager']['timeout']))
self.services['_controller'] = self
# start services
self.logger.info('Starting services...')
services.startServices()
except Exception, e:
self.logger.log(logging.ERROR, e[0], *(), **{'exc_info' : True})
raise e
def getFiltersList(contextNode):
filterList = contextNode.getElementsByTagName('filter')
filters = []
for filterNode in filterList:
type = filterNode.getAttribute('type').encode('iso-8859-1')
filter = [misc.getCallableByName(type), {}]
for attr in filterNode.attributes.keys():
filter[1][str(attr)] = filterNode.getAttribute(attr).encode('iso-8859-1')
filters.append( tuple(filter) )
return tuple(filters)
def on_update(cls, item, new_attr, old_attr, trans):
from porcupine.systemObjects import Composite
# load objects
dctObjects = {}
for i, obj in enumerate(new_attr.value):
if isinstance(obj, Composite):
obj._containerid = item._id
elif isinstance(obj, str):
obj = _db.getItem(obj, trans)
new_attr.value[i] = obj
else:
raise exceptions.ContainmentError, \
'Invalid object type "%s" in composition.' % \
obj.__class__.__name__
dctObjects[obj._id] = obj
# check containment
compositeClass = misc.getCallableByName(new_attr.compositeClass)
if [obj for obj in dctObjects.values()
if not isinstance(obj, compositeClass)]:
raise exceptions.ContainmentError, \
'Invalid content class "%s" in composition.' % \
obj.getContentclass()
# get previous value
if old_attr != None:
old_ids = set(old_attr.value)
else:
old_ids = set()
new_ids = set([obj._id for obj in new_attr.value])
# calculate added composites
lstAdded = list(new_ids - old_ids)
for obj_id in lstAdded:
_db.handle_update(dctObjects[obj_id], None, trans)
dctObjects[obj_id]._isDeleted = False
_db.putItem(dctObjects[obj_id], trans)
# calculate constant composites
lstConstant = list(new_ids & old_ids)
for obj_id in lstConstant:
_db.handle_update(dctObjects[obj_id],
_db.getItem(obj_id, trans),
trans)
_db.putItem(dctObjects[obj_id], trans)
# calculate removed composites
lstRemoved = list(old_ids - new_ids)
for obj_id in lstRemoved:
composite4removal = _db.getItem(obj_id, trans)
cls.removeComposite(composite4removal, trans)
new_attr.value = list(new_ids)
def getHandle():
#open database
_db.open(misc.getCallableByName(settings['store']['interface']))
#create in-memory session manager
SessionManager.open(inMemorySessionManager.SessionManager, 1200)
oSystemUser = _db.getItem('system')
context = HttpContext()
context.session = SessionManager.create(oSystemUser)
currentThread().context = context
currentThread().trans = None
return _db
def __init__(self, identifier, enc, filters, max_age):
try:
self.context = misc.getCallableByName(identifier)
self.type = 2
except:
self.context = identifier
if identifier[-4:] == '.psp':
self.type = 1
else:
self.type = 0
self.encoding = enc
self.filters = filters
self.max_age = int(max_age);
def apply(response, request, registration, args):
language = request.getLang()
lst_resources = args['using'].split(',')
bundles = [misc.getCallableByName( x )
for x in lst_resources]
output = response._getBody()
tokens = frozenset(re.findall(TOKEN, output, re.DOTALL))
for token, key in tokens:
for bundle in bundles:
res = bundle.getResource(key, language)
if res != key:
break
output = output.replace(token, res)
response._body = [output]
def apply(context, registration, **kwargs):
language = context.request.getLang()
lst_resources = kwargs['using'].split(',')
bundles = [misc.getCallableByName(x)
for x in lst_resources]
output = context.response._body.getvalue()
tokens = frozenset(re.findall(I18n._tokens, output, re.DOTALL))
for token, key in tokens:
for bundle in bundles:
res = bundle.getResource(key, language)
if res != key:
break
output = output.replace(token, res)
context.response.clear()
context.response.write(output)
def _getFullName(self, callable):
module = misc.getCallableByName(callable.__module__)
if self._imports.has_key(module):
return self._imports[module] + "." + callable.__name__
else:
if module == self._module:
return callable.__name__
self._newimports.append(module)
local_name = callable.__module__.split(".")[-1]
counter = 2
while local_name in self._module.__dict__:
local_name += str(counter)
counter += 1
self._imports[module] = local_name
return local_name + "." + callable.__name__
def startServices():
for service in settings['services']:
name = service['name']
type = service['type']
service_class = misc.getCallableByName(service['class'])
if type == 'TCPListener':
address = misc.getAddressFromString(service['address'])
worker_threads = int(service['worker_threads'])
services[name] = service_class(name, address, worker_threads)
elif type == 'ScheduledTask':
interval = int(service['interval'])
services[name] = service_class(name, interval)
# add parameters
if service.has_key('parameters'):
services[name].parameters = service['parameters']
# start service
services[name].start()
def open():
global db_handle, object_cache
db_handle = misc.getCallableByName(
settings['store']['interface'])()
def _recover():
global db_handle
db_handle = misc.getCallableByName(
settings['store']['interface'])._recover()
or imp.is_frozen("__main__")) # tools/freeze
if main_is_frozen():
sys.path.insert(0, '')
from porcupine.db import _db
from porcupine.utils import misc
answer = raw_input('''WARNING: Please ensure that Porcupine Server is stopped!
All objects will be erased!
Are you sure you want to initialize the database(Y/N)?''')
if (answer == 'Y'):
try:
from porcupine.config.settings import settings
_db.open(misc.getCallableByName(settings['store']['interface']))
except Exception, e:
sys.exit(e[0])
import porcupine.systemObjects
import org.innoscript.desktop.schema.common
import org.innoscript.desktop.schema.security
# truncate database
sys.stdout.write('Deleting existing database...')
_db.db_handle._truncate()
sys.stdout.write('[OK]\n')
sOwner = 'SYSTEM'
ftime = time.time()
def h_66(params, variables, forObject):
className = evaluateStack(params[0][:], variables, forObject)
return isinstance(forObject, misc.getCallableByName(className))
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with Porcupine; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#===============================================================================
"Server request interfaces"
from porcupine.config.settings import settings
from porcupine.utils import misc
from porcupine import serverExceptions
requestInterfaces = {}
try:
ris = settings.requestinterfaces.options
except AttributeError:
raise serverExceptions.ConfigurationError, 'The configuration file either has no [requestinterfaces] section or the aforementioned section is blank'
for ri in ris:
sInterface = getattr(settings.requestinterfaces, ri)
try:
requestInterfaces[ri.upper()] = misc.getCallableByName(sInterface)
except AttributeError:
raise serverExceptions.ConfigurationError, 'Invalid request interface "%s"' % sInterface
except ImportError:
raise serverExceptions.ConfigurationError, 'Invalid request interface "%s"' % sInterface
del ris
from porcupine.config.settings import settings
from porcupine.utils import misc
from porcupine import serverExceptions
try:
sm_class = settings.sessionmanager.interface
except AttributeError:
raise serverExceptions.ConfigurationError, \
(('interface', 'sessionmanager'),)
try:
timeout = int(settings.sessionmanager.timeout)
except AttributeError:
# default timeout set to 20 minutes
timeout = 1200
except ValueError:
raise serverExceptions.ConfigurationError, \
'Invalid value for session manager timeout: %s' % \
settings.sessionmanager.timeout
try:
sm_class = misc.getCallableByName(sm_class)
except AttributeError:
raise serverExceptions.ConfigurationError, \
'Invalid session manager interface "%s"' % \
settings.sessionmanager.interface
except ImportError:
raise serverExceptions.ConfigurationError, \
'Invalid session manager interface "%s"' % \
settings.sessionmanager.interface
# the Free Software Foundation; either version 2.1 of the License, or
# (at your option) any later version.
# Porcupine is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with Porcupine; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#===============================================================================
"Server database parameters"
from porcupine import serverExceptions
from porcupine.config.settings import settings
from porcupine.utils import misc
try:
db_class = settings.store.interface
except AttributeError:
raise serverExceptions.ConfigurationError, (('interface', 'store'),)
try:
db_class = misc.getCallableByName(db_class)
except AttributeError:
raise serverExceptions.ConfigurationError, 'Invalid store interface "%s"' % settings.store.interface
except ImportError:
raise serverExceptions.ConfigurationError, 'Invalid store interface "%s"' % settings.store.interface
params = settings.storeparameters.toDict()
