def gets_the_detail_of_an_instance_test():
r = requests.get(url('instances'), headers=default_headers())
company_id = next(c['companyId'] for c in r.json() if c['mx'] == 'liferay.com')
r = requests.get(url('instances', company_id), headers=default_headers())
assert r.status_code == 200
assert r.json()['companyId'] == company_id
def gets_all_available_sites_test():
r = requests.get(url('instances'), headers=default_headers())
company_id = next(c['companyId'] for c in r.json() if c['mx'] == 'liferay.com')
r = requests.get(url('instances', company_id, 'sites'), headers=default_headers())
assert r.status_code == 200
assert len(r.json()) > 0
def addResourceTarget(module,type,name,kwargs):
pages.require("/admin/modules.edit")
#Create a permission
if type == 'permission':
with modulesLock:
if kwargs['name'] in ActiveModules[module]:
raise cherrypy.HTTPRedirect("/errors/alreadyexists")
else:
ActiveModules[module] [kwargs['name']]= {"resource-type":"permission","description":kwargs['description']}
#has its own lock
auth.importPermissionsFromModules() #sync auth's list of permissions
raise cherrypy.HTTPRedirect("/modules/module/" +util.url(module)+ '/resource/' + util.url(name) )
if type == 'event':
with modulesLock:
if kwargs['name'] not in ActiveModules[module]:
ActiveModules[module] [kwargs['name']]= {"resource-type":"event","trigger":"False","action":"pass",
"once":True}
#newevt maintains a cache of precompiled events that must be kept in sync with
#the modules
newevt.updateOneEvent(kwargs['name'],module)
raise cherrypy.HTTPRedirect("/modules/module/"+util.url(module)+'/resource/'+util.url(name))
else:
raise cherrypy.HTTPRedirect("/errors/alreadyexists")
if type == 'page':
with modulesLock:
if kwargs['name'] not in ActiveModules[module]:
ActiveModules[module][kwargs['name']]= {"resource-type":"page","body":"Content here",'no-navheader':True}
#newevt maintains a cache of precompiled events that must be kept in sync with
#the modules
raise cherrypy.HTTPRedirect("/modules/module/"+util.url(module)+'/resource/'+util.url(name))
else:
raise cherrypy.HTTPRedirect("/errors/alreadyexists")
def gets_a_site_detail_test():
r = requests.get(url('instances'), headers=default_headers())
company_id = next(c['companyId'] for c in r.json() if c['mx'] == 'liferay.com')
r = requests.get(url('instances', company_id, 'sites'), headers=default_headers())
group_id = next(g['classPK'] for g in r.json() if g['friendlyURL'] == '/guest')
r = requests.get(url('instances', company_id, 'sites', group_id),
headers=default_headers())
assert r.status_code == 200
assert r.json()['classPK'] == group_id
def returns_all_site_articles_test():
r = requests.get(url('instances'), headers=default_headers())
company_id = next(c['companyId'] for c in r.json() if c['mx'] == 'liferay.com')
r = requests.get(url('instances', company_id, 'sites'),
headers=default_headers())
group_id = next(g['classPK'] for g in r.json() if g['friendlyURL'] == '/guest')
r = requests.get(url('instances', company_id, 'sites', group_id, 'articles'),
headers=default_headers())
assert r.status_code == 200
assert len(r.json()) >= 0
def getModuleAsZip(module):
with modulesLock:
#We use a stringIO so we can avoid using a real file.
ram_file = StringIO()
z = zipfile.ZipFile(ram_file,'w')
#Dump each resource to JSON in the ZIP
for resource in ActiveModules[module]:
#AFAIK Zip files fake the directories with naming conventions
s = json.dumps(ActiveModules[module][resource],sort_keys=True,indent=4, separators=(',', ': '))
z.writestr(url(module)+'/'+url(resource)+".json",s)
z.close()
s = ram_file.getvalue()
ram_file.close()
return s
def openpath(ui, path):
"""open path with open if local, url.open if remote"""
pathurl = util.url(path, parsequery=False, parsefragment=False)
if pathurl.islocal():
return util.posixfile(pathurl.localpath(), "rb")
else:
return url.open(ui, path)
def __init__(self, ui, path):
self._url = path
self.ui = ui
self.root = path
u = util.url(path.rstrip("/") + "/.hg")
self.path, authinfo = u.authinfo()
opener = build_opener(ui, authinfo)
self.opener = opener(self.path)
self.vfs = self.opener
self._phasedefaults = []
try:
requirements = scmutil.readrequires(self.opener, self.supported)
except IOError, inst:
if inst.errno != errno.ENOENT:
raise
requirements = set()
# check if it is a non-empty old-style repository
try:
fp = self.opener("00changelog.i")
fp.read(1)
fp.close()
except IOError, inst:
if inst.errno != errno.ENOENT:
raise
# we do not care about empty old-style repositories here
msg = _("'%s' does not appear to be an hg repository") % path
raise error.RepoError(msg)
def __init__(self, ui, path, create=False):
self._url = path
self.ui = ui
self.pipeo = self.pipei = self.pipee = None
u = util.url(path, parsequery=False, parsefragment=False)
if u.scheme != 'ssh' or not u.host or u.path is None:
self._abort(error.RepoError(_("couldn't parse location %s") % path))
self.user = u.user
if u.passwd is not None:
self._abort(error.RepoError(_("password in URL not supported")))
self.host = u.host
self.port = u.port
self.path = u.path or "."
sshcmd = self.ui.config("ui", "ssh", "ssh")
remotecmd = self.ui.config("ui", "remotecmd", "hg")
args = util.sshargs(sshcmd, self.host, self.user, self.port)
if create:
cmd = '%s %s %s' % (sshcmd, args,
util.shellquote("%s init %s" %
(_serverquote(remotecmd), _serverquote(self.path))))
ui.debug('running %s\n' % cmd)
res = util.system(cmd, out=ui.fout)
if res != 0:
self._abort(error.RepoError(_("could not create remote repo")))
self._validaterepo(sshcmd, args, remotecmd)
def __init__(self, ui, path, create=False):
self._url = path
self.ui = ui
u = util.url(path, parsequery=False, parsefragment=False)
if u.scheme != "ssh" or not u.host or u.path is None:
self._abort(error.RepoError(_("couldn't parse location %s") % path))
self.user = u.user
if u.passwd is not None:
self._abort(error.RepoError(_("password in URL not supported")))
self.host = u.host
self.port = u.port
self.path = u.path or "."
sshcmd = self.ui.config("ui", "ssh", "ssh")
remotecmd = self.ui.config("ui", "remotecmd", "hg")
args = util.sshargs(sshcmd, self.host, self.user, self.port)
if create:
cmd = '%s %s "%s init %s"'
cmd = cmd % (sshcmd, args, remotecmd, self.path)
ui.note(_("running %s\n") % cmd)
res = util.system(cmd)
if res != 0:
self._abort(error.RepoError(_("could not create remote repo")))
self.validate_repo(ui, sshcmd, args, remotecmd)
def find_user_password(self, realm, authuri):
authinfo = urllib2.HTTPPasswordMgrWithDefaultRealm.find_user_password(
self, realm, authuri)
user, passwd = authinfo
if user and passwd:
self._writedebug(user, passwd)
return (user, passwd)
if not user or not passwd:
res = httpconnectionmod.readauthforuri(self.ui, authuri, user)
if res:
group, auth = res
user, passwd = auth.get('username'), auth.get('password')
self.ui.debug("using auth.%s.* for authentication\n" % group)
if not user or not passwd:
u = util.url(authuri)
u.query = None
if not self.ui.interactive():
raise util.Abort(_('http authorization required for %s') %
util.hidepassword(str(u)))
self.ui.write(_("http authorization required for %s\n") %
util.hidepassword(str(u)))
self.ui.write(_("realm: %s\n") % realm)
if user:
self.ui.write(_("user: %s\n") % user)
else:
user = self.ui.prompt(_("user:"), default=None)
if not passwd:
passwd = self.ui.getpass()
self.add_password(realm, authuri, user, passwd)
self._writedebug(user, passwd)
return (user, passwd)
def instance(ui, path, create):
if create:
raise util.Abort(_('cannot create new bundle repository'))
parentpath = ui.config("bundle", "mainreporoot", "")
if not parentpath:
# try to find the correct path to the working directory repo
parentpath = cmdutil.findrepo(os.getcwd())
if parentpath is None:
parentpath = ''
if parentpath:
# Try to make the full path relative so we get a nice, short URL.
# In particular, we don't want temp dir names in test outputs.
cwd = os.getcwd()
if parentpath == cwd:
parentpath = ''
else:
cwd = os.path.join(cwd,'')
if parentpath.startswith(cwd):
parentpath = parentpath[len(cwd):]
u = util.url(path)
path = u.localpath()
if u.scheme == 'bundle':
s = path.split("+", 1)
if len(s) == 1:
repopath, bundlename = parentpath, s[0]
else:
repopath, bundlename = s
else:
repopath, bundlename = parentpath, path
return bundlerepository(ui, repopath, bundlename)
def _peerlookup(path):
u = util.url(path)
scheme = u.scheme or 'file'
thing = schemes.get(scheme) or schemes['file']
try:
return thing(path)
except TypeError:
return thing
def getModuleAsZip(module):
with modulesLock:
#We use a stringIO so we can avoid using a real file.
ram_file = StringIO()
z = zipfile.ZipFile(ram_file, 'w')
#Dump each resource to JSON in the ZIP
for resource in ActiveModules[module]:
#AFAIK Zip files fake the directories with naming conventions
s = json.dumps(ActiveModules[module][resource],
sort_keys=True,
indent=4,
separators=(',', ': '))
z.writestr(url(module) + '/' + url(resource) + ".json", s)
z.close()
s = ram_file.getvalue()
ram_file.close()
return s
def parseurl(path, branches=None):
'''parse url#branch, returning (url, (branch, branches))'''
u = util.url(path)
branch = None
if u.fragment:
branch = u.fragment
u.fragment = None
return str(u), (branch, branches or [])
def parseurl(path, branches=None):
'''parse url#branch, returning (url, (branch, branches))'''
u = util.url(path)
branch = None
if u.fragment:
branch = u.fragment
u.fragment = None
return str(u), (branch, branches or [])
def open(ui, url_, data=None):
u = util.url(url_)
if u.scheme:
u.scheme = u.scheme.lower()
url_, authinfo = u.authinfo()
else:
path = util.normpath(os.path.abspath(url_))
url_ = 'file://' + urllib.pathname2url(path)
authinfo = None
return opener(ui, authinfo).open(url_, data)
def open(ui, url_, data=None):
u = util.url(url_)
if u.scheme:
u.scheme = u.scheme.lower()
url_, authinfo = u.authinfo()
else:
path = util.normpath(os.path.abspath(url_))
url_ = 'file://' + urllib.pathname2url(path)
authinfo = None
return opener(ui, authinfo).open(url_, data)
def addResourceTarget(module,type,name,kwargs):
pages.require("/admin/modules.edit")
global moduleschanged
moduleschanged = True
def insertResource(r):
ActiveModules[module][kwargs['name']] = r
with modulesLock:
#Check if a resource by that name is already there
if kwargs['name'] in ActiveModules[module]:
raise cherrypy.HTTPRedirect("/errors/alreadyexists")
#Create a permission
if type == 'permission':
insertResource({
"resource-type":"permission",
"description":kwargs['description']})
#has its own lock
auth.importPermissionsFromModules() #sync auth's list of permissions
if type == 'event':
insertResource({
"resource-type":"event",
"trigger":"False",
"action":"pass",
"once":True})
#newevt maintains a cache of precompiled events that must be kept in sync with
#the modules
newevt.updateOneEvent(kwargs['name'],module)
if type == 'page':
insertResource({
"resource-type":"page",
"body":"Content here",
'no-navheader':True})
usrpages.updateOnePage(kwargs['name'],module)
messagebus.postMessage("/system/notifications", "User "+ pages.getAcessingUser() + " added resource " +
kwargs['name'] + " of type " + type+" to module " + module)
#Take the user straight to the resource page
raise cherrypy.HTTPRedirect("/modules/module/"+util.url(module)+'/resource/'+util.url(name))
def resourceUpdateTarget(module, resource, kwargs):
pages.require("/admin/modules.edit")
global moduleschanged
moduleschanged = True
with modulesLock:
t = ActiveModules[module][resource]['resource-type']
resourceobj = ActiveModules[module][resource]
if t == 'permission':
resourceobj['description'] = kwargs['description']
#has its own lock
auth.importPermissionsFromModules(
) #sync auth's list of permissions
if t == 'event':
e = newevt.Event(kwargs['trigger'], kwargs['action'],
{}) #Test compile, throw error on fail.
resourceobj['trigger'] = kwargs['trigger']
resourceobj['action'] = kwargs['action']
resourceobj['setup'] = kwargs['setup']
resourceobj['priority'] = max([int(kwargs['priority']), 0])
resourceobj['continual'] = 'continual' in kwargs
resourceobj['rate-limit'] = float(kwargs['ratelimit'])
#I really need to do something about this possibly brittle bookkeeping system
#But anyway, when the active modules thing changes we must update the newevt cache thing.
newevt.updateOneEvent(resource, module)
if t == 'page':
resourceobj['body'] = kwargs['body']
resourceobj['no-navheader'] = 'no-navheader' in kwargs
resourceobj['no-header'] = 'no-header' in kwargs
resourceobj['dont-show-in-index'] = 'dont-show-in-index' in kwargs
#Method checkboxes
resourceobj['require-method'] = []
if 'allow-GET' in kwargs:
resourceobj['require-method'].append('GET')
if 'allow-POST' in kwargs:
resourceobj['require-method'].append('POST')
#permission checkboxes
resourceobj['require-permissions'] = []
for i in kwargs:
#Since HTTP args don't have namespaces we prefix all the permission checkboxes with permission
if i[:10] == 'Permission':
if kwargs[i] == 'true':
resourceobj['require-permissions'].append(i[10:])
usrpages.updateOnePage(resource, module)
messagebus.postMessage(
"/system/notifications", "User " + pages.getAcessingUser() +
" modified resource " + resource + " of module " + module)
#Return user to the module page
raise cherrypy.HTTPRedirect(
"/modules/module/" +
util.url(module)) #+'/resource/'+util.url(resource))
def _peerlookup(path):
u = util.url(path)
scheme = u.scheme or 'file'
thing = schemes.get(scheme) or schemes['file']
try:
return thing(path)
except TypeError:
# we can't test callable(thing) because 'thing' can be an unloaded
# module that implements __call__
if not util.safehasattr(thing, 'instance'):
raise
return thing
def _peerlookup(path):
u = util.url(path)
scheme = u.scheme or "file"
thing = schemes.get(scheme) or schemes["file"]
try:
return thing(path)
except TypeError:
# we can't test callable(thing) because 'thing' can be an unloaded
# module that implements __call__
if not util.safehasattr(thing, "instance"):
raise
return thing
def saveModules(where):
with modulesLock:
for i in ActiveModules:
#Iterate over all of the resources in a module and save them as json files
#under the URL urld module name for the filename.
for resource in ActiveModules[i]:
#Make sure there is a directory at where/module/
util.ensure_dir(os.path.join(where,url(i),url(resource)) )
#Open a file at /where/module/resource
with open(os.path.join(where,url(i),url(resource)),"w") as f:
#Make a json file there and prettyprint it
json.dump(ActiveModules[i][resource],f,sort_keys=True,indent=4, separators=(',', ': '))
#Now we iterate over the existing resource files in the filesystem and delete those that correspond to
#modules that have been deleted in the ActiveModules workspace thing.
for i in util.get_immediate_subdirectories(os.path.join(where,url(i))):
if unurl(i) not in ActiveModules:
os.remove(os.path.join(where,url(i),i))
for i in util.get_immediate_subdirectories(where):
#Look in the modules directory, and if the module folder is not in ActiveModules\
#We assume the user deleted the module so we should delete the save file for it.
#Note that we URL url file names for the module filenames and foldernames.
if unurl(i) not in ActiveModules:
shutil.rmtree(os.path.join(where,i))
with open(os.path.join(where,'__COMPLETE__'),'w') as f:
f.write("By this string of contents quite arbitrary, I hereby mark this dump as consistant!!!")
def saveModules(where):
with modulesLock:
for i in ActiveModules:
#Iterate over all of the resources in a module and save them as json files
#under the URL urld module name for the filename.
for resource in ActiveModules[i]:
#Make sure there is a directory at where/module/
util.ensure_dir(os.path.join(where, url(i), url(resource)))
#Open a file at /where/module/resource
with open(os.path.join(where, url(i), url(resource)),
"w") as f:
#Make a json file there and prettyprint it
json.dump(ActiveModules[i][resource],
f,
sort_keys=True,
indent=4,
separators=(',', ': '))
#Now we iterate over the existing resource files in the filesystem and delete those that correspond to
#modules that have been deleted in the ActiveModules workspace thing.
for i in util.get_immediate_subdirectories(
os.path.join(where, url(i))):
if unurl(i) not in ActiveModules:
os.remove(os.path.join(where, url(i), i))
for i in util.get_immediate_subdirectories(where):
#Look in the modules directory, and if the module folder is not in ActiveModules\
#We assume the user deleted the module so we should delete the save file for it.
#Note that we URL url file names for the module filenames and foldernames.
if unurl(i) not in ActiveModules:
shutil.rmtree(os.path.join(where, i))
with open(os.path.join(where, '__COMPLETE__'), 'w') as f:
f.write(
"By this string of contents quite arbitrary, I hereby mark this dump as consistant!!!"
)
def savefiles(where):
with persistance_dict_connection_lock:
for i in persistancedicts:
#Nobody can chang it while we are saving
with persistancedicts[i].lock:
#Open a file at /where/module/resource
with open(os.path.join(where,url(i)),"w") as f:
#Make a json file there and prettyprint it
json.dump(persistancedicts[i].d,f,sort_keys=True,indent=4, separators=(',', ': '))
with open(os.path.join(where,'__COMPLETE__'),'w') as f:
f.write("By this string of contents quite arbitrary, I hereby mark this dump as consistant!!!")
def __init__(self, ui, path):
self._url = path
self.ui = ui
self.root = path
u = util.url(path.rstrip('/') + "/.hg")
self.path, authinfo = u.authinfo()
opener = build_opener(ui, authinfo)
self.opener = opener(self.path)
self.vfs = self.opener
self._phasedefaults = []
self.names = namespaces.namespaces()
try:
requirements = scmutil.readrequires(self.vfs, self.supported)
except IOError as inst:
if inst.errno != errno.ENOENT:
raise
requirements = set()
# check if it is a non-empty old-style repository
try:
fp = self.vfs("00changelog.i")
fp.read(1)
fp.close()
except IOError as inst:
if inst.errno != errno.ENOENT:
raise
# we do not care about empty old-style repositories here
msg = _("'%s' does not appear to be an hg repository") % path
raise error.RepoError(msg)
# setup store
self.store = store.store(requirements, self.path, opener)
self.spath = self.store.path
self.svfs = self.store.opener
self.sjoin = self.store.join
self._filecache = {}
self.requirements = requirements
self.manifest = manifest.manifest(self.svfs)
self.changelog = changelog.changelog(self.svfs)
self._tags = None
self.nodetagscache = None
self._branchcaches = {}
self._revbranchcache = None
self.encodepats = None
self.decodepats = None
self._transref = None
def __init__(self, ui, path):
self._url = path
self.ui = ui
self.root = path
u = util.url(path.rstrip('/') + "/.hg")
self.path, authinfo = u.authinfo()
opener = build_opener(ui, authinfo)
self.opener = opener(self.path)
self.vfs = self.opener
self._phasedefaults = []
self.names = namespaces.namespaces()
try:
requirements = scmutil.readrequires(self.vfs, self.supported)
except IOError as inst:
if inst.errno != errno.ENOENT:
raise
requirements = set()
# check if it is a non-empty old-style repository
try:
fp = self.vfs("00changelog.i")
fp.read(1)
fp.close()
except IOError as inst:
if inst.errno != errno.ENOENT:
raise
# we do not care about empty old-style repositories here
msg = _("'%s' does not appear to be an hg repository") % path
raise error.RepoError(msg)
# setup store
self.store = store.store(requirements, self.path, opener)
self.spath = self.store.path
self.svfs = self.store.opener
self.sjoin = self.store.join
self._filecache = {}
self.requirements = requirements
self.manifest = manifest.manifest(self.svfs)
self.changelog = changelog.changelog(self.svfs)
self._tags = None
self.nodetagscache = None
self._branchcaches = {}
self._revbranchcache = None
self.encodepats = None
self.decodepats = None
self._transref = None
def module(self,module,*path,**kwargs):
#If we are not performing an action on a module just going to its page
if not path:
pages.require("/admin/modules.view")
return pages.get_template("modules/module.html").render(module = ActiveModules[module],name = module)
else:
#This gets the interface to add a page
if path[0] == 'addresource':
#path[1] tells what type of resource is being created and addResourceDispatcher returns the appropriate crud screen
return addResourceDispatcher(module,path[1])
#This case handles the POST request from the new resource target
if path[0] == 'addresourcetarget':
return addResourceTarget(module,path[1],kwargs['name'],kwargs)
#This case shows the information and editing page for one resource
if path[0] == 'resource':
return resourceEditPage(module,path[1])
#This goes to a dispatcher that takes into account the type of resource and updates everything about the resource.
if path[0] == 'updateresource':
return resourceUpdateTarget(module,path[1],kwargs)
#This returns a page to delete any resource by name
if path[0] == 'deleteresource':
pages.require("/admin/modules.edit")
return pages.get_template("modules/deleteresource.html").render(module=module)
#This handles the POST request to actually do the deletion
if path[0] == 'deleteresourcetarget':
pages.require("/admin/modules.edit")
with modulesLock:
r = ActiveModules[module].pop(kwargs['name'])
#Annoying bookkeeping crap to get rid of the cached crap
if r['resource-type'] == 'event':
newevt.removeOneEvent(kwargs['name'])
if r['resource-type'] == 'permission':
auth.importPermissionsFromModules() #sync auth's list of permissions
raise cherrypy.HTTPRedirect('/modules')
#This is the target used to change the name and description(basic info) of a module
if path[0] == 'update':
pages.require("/admin/modules.edit")
with modulesLock:
ActiveModules[kwargs['name']] = ActiveModules.pop(module)
ActiveModules[module]['__description']['text'] = kwargs['description']
raise cherrypy.HTTPRedirect('/modules/module/'+util.url(kwargs['name']))
def _abssource(repo, push=False, abort=True):
"""return pull/push path of repo - either based on parent repo .hgsub info
or on the top repo config. Abort or return None if no source found."""
if util.safehasattr(repo, "_subparent"):
source = util.url(repo._subsource)
if source.isabs():
return str(source)
source.path = posixpath.normpath(source.path)
parent = _abssource(repo._subparent, push, abort=False)
if parent:
parent = util.url(parent)
parent.path = posixpath.join(parent.path or "", source.path)
parent.path = posixpath.normpath(parent.path)
return str(parent)
else: # recursion reached top repo
if util.safehasattr(repo, "_subtoppath"):
return repo._subtoppath
if push and repo.ui.config("paths", "default-push"):
return repo.ui.config("paths", "default-push")
if repo.ui.config("paths", "default"):
return repo.ui.config("paths", "default")
if abort:
raise util.Abort(_("default path for subrepository %s not found") % reporelpath(repo))
def resourceUpdateTarget(module,resource,kwargs):
pages.require("/admin/modules.edit")
global moduleschanged
moduleschanged = True
with modulesLock:
t = ActiveModules[module][resource]['resource-type']
resourceobj = ActiveModules[module][resource]
if t == 'permission':
resourceobj['description'] = kwargs['description']
#has its own lock
auth.importPermissionsFromModules() #sync auth's list of permissions
if t == 'event':
e = newevt.Event(kwargs['trigger'],kwargs['action'],{})#Test compile, throw error on fail.
resourceobj['trigger'] = kwargs['trigger']
resourceobj['action'] = kwargs['action']
resourceobj['setup'] = kwargs['setup']
resourceobj['priority'] = max([int(kwargs['priority']),0])
resourceobj['continual'] = 'continual' in kwargs
resourceobj['rate-limit'] = float(kwargs['ratelimit'])
#I really need to do something about this possibly brittle bookkeeping system
#But anyway, when the active modules thing changes we must update the newevt cache thing.
newevt.updateOneEvent(resource,module)
if t == 'page':
resourceobj['body'] = kwargs['body']
resourceobj['no-navheader'] = 'no-navheader' in kwargs
resourceobj['no-header'] = 'no-header' in kwargs
resourceobj['dont-show-in-index'] = 'dont-show-in-index' in kwargs
#Method checkboxes
resourceobj['require-method'] = []
if 'allow-GET' in kwargs:
resourceobj['require-method'].append('GET')
if 'allow-POST' in kwargs:
resourceobj['require-method'].append('POST')
#permission checkboxes
resourceobj['require-permissions'] = []
for i in kwargs:
#Since HTTP args don't have namespaces we prefix all the permission checkboxes with permission
if i[:10] == 'Permission':
if kwargs[i] == 'true':
resourceobj['require-permissions'].append(i[10:])
usrpages.updateOnePage(resource,module)
messagebus.postMessage("/system/notifications", "User "+ pages.getAcessingUser() + " modified resource " +
resource + " of module " + module)
#Return user to the module page
raise cherrypy.HTTPRedirect("/modules/module/"+util.url(module))#+'/resource/'+util.url(resource))
def posts_a_new_site_and_then_deletes_it_test():
r = requests.get(url('instances'), headers=default_headers())
company_id = next(c['companyId'] for c in r.json() if c['mx'] == 'liferay.com')
r = requests.post(url('instances', company_id, 'sites'),
headers=default_headers(),
data=json.dumps({
'userId': 2,
'className': None,
'classPK': 0,
'liveGroupId': 0,
'name': 'foo',
'description': 'bar',
'groupType': 1,
'friendlyURL': '/foo',
'site': True,
'active': False
}))
group_id = r.json()['classPK']
r = requests.delete(url('instances', company_id, 'sites', group_id),
headers=default_headers())
assert r.status_code == 200
def newmoduletarget(self,**kwargs):
global scopes
pages.require("/admin/modules.edit")
#If there is no module by that name, create a blank template and the scope obj
with modulesLock:
if kwargs['name'] not in ActiveModules:
ActiveModules[kwargs['name']] = {"__description":
{"resource-type":"module-description",
"text":"Module info here"}}
#Create the scope that code in the module will run in
scopes[kwargs['name']] = {}
#Go directly to the newly created module
raise cherrypy.HTTPRedirect("/modules/module/"+util.url(kwargs['name']))
else:
return pages.get_template("error.html").render(info = " A module already exists by that name,")
def __init__(self, ui, path):
self.path = path
self.caps = None
self.handler = None
u = util.url(path)
if u.query or u.fragment:
raise util.Abort(_('unsupported URL component: "%s"') % (u.query or u.fragment))
# urllib cannot handle URLs with embedded user or passwd
self._url, authinfo = u.authinfo()
self.ui = ui
self.ui.debug("using %s\n" % self._url)
self.urlopener = url.opener(ui, authinfo)
def __init__(self, ui):
proxyurl = ui.config("http_proxy", "host") or os.getenv('http_proxy')
# XXX proxyauthinfo = None
if proxyurl:
# proxy can be proper url or host[:port]
if not (proxyurl.startswith('http:')
or proxyurl.startswith('https:')):
proxyurl = 'http://' + proxyurl + '/'
proxy = util.url(proxyurl)
if not proxy.user:
proxy.user = ui.config("http_proxy", "user")
proxy.passwd = ui.config("http_proxy", "passwd")
# see if we should use a proxy for this url
no_list = ["localhost", "127.0.0.1"]
no_list.extend(
[p.lower() for p in ui.configlist("http_proxy", "no")])
no_list.extend([
p.strip().lower() for p in os.getenv("no_proxy", '').split(',')
if p.strip()
])
# "http_proxy.always" config is for running tests on localhost
if ui.configbool("http_proxy", "always"):
self.no_list = []
else:
self.no_list = no_list
proxyurl = str(proxy)
proxies = {'http': proxyurl, 'https': proxyurl}
ui.debug('proxying through http://%s:%s\n' %
(proxy.host, proxy.port))
else:
proxies = {}
# urllib2 takes proxy values from the environment and those
# will take precedence if found. So, if there's a config entry
# defining a proxy, drop the environment ones
if ui.config("http_proxy", "host"):
for env in ["HTTP_PROXY", "http_proxy", "no_proxy"]:
try:
if env in os.environ:
del os.environ[env]
except OSError:
pass
urllib2.ProxyHandler.__init__(self, proxies)
self.ui = ui
def __init__(self, ui):
proxyurl = ui.config("http_proxy", "host") or os.getenv('http_proxy')
# XXX proxyauthinfo = None
if proxyurl:
# proxy can be proper url or host[:port]
if not (proxyurl.startswith('http:') or
proxyurl.startswith('https:')):
proxyurl = 'http://' + proxyurl + '/'
proxy = util.url(proxyurl)
if not proxy.user:
proxy.user = ui.config("http_proxy", "user")
proxy.passwd = ui.config("http_proxy", "passwd")
# see if we should use a proxy for this url
no_list = ["localhost", "127.0.0.1"]
no_list.extend([p.lower() for
p in ui.configlist("http_proxy", "no")])
no_list.extend([p.strip().lower() for
p in os.getenv("no_proxy", '').split(',')
if p.strip()])
# "http_proxy.always" config is for running tests on localhost
if ui.configbool("http_proxy", "always"):
self.no_list = []
else:
self.no_list = no_list
proxyurl = str(proxy)
proxies = {'http': proxyurl, 'https': proxyurl}
ui.debug('proxying through http://%s:%s\n' %
(proxy.host, proxy.port))
else:
proxies = {}
# urllib2 takes proxy values from the environment and those
# will take precedence if found. So, if there's a config entry
# defining a proxy, drop the environment ones
if ui.config("http_proxy", "host"):
for env in ["HTTP_PROXY", "http_proxy", "no_proxy"]:
try:
if env in os.environ:
del os.environ[env]
except OSError:
pass
urllib2.ProxyHandler.__init__(self, proxies)
self.ui = ui
def __init__(self, ui, path):
self.path = path
self.caps = None
self.handler = None
self.urlopener = None
u = util.url(path)
if u.query or u.fragment:
raise util.Abort(_('unsupported URL component: "%s"') %
(u.query or u.fragment))
# urllib cannot handle URLs with embedded user or passwd
self._url, authinfo = u.authinfo()
self.ui = ui
self.ui.debug('using %s\n' % self._url)
self.urlopener = url.opener(ui, authinfo)
def newmoduletarget(self,**kwargs):
global scopes
pages.require("/admin/modules.edit")
global moduleschanged
moduleschanged = True
#If there is no module by that name, create a blank template and the scope obj
with modulesLock:
if kwargs['name'] not in ActiveModules:
ActiveModules[kwargs['name']] = {"__description":
{"resource-type":"module-description",
"text":"Module info here"}}
#Create the scope that code in the module will run in
scopes[kwargs['name']] = obj()
#Go directly to the newly created module
messagebus.postMessage("/system/notifications","User "+ pages.getAcessingUser() + " Created Module " + kwargs['name'])
raise cherrypy.HTTPRedirect("/modules/module/"+util.url(kwargs['name']))
else:
return pages.get_template("error.html").render(info = " A module already exists by that name,")
def defaultdest(source):
"""return default destination of clone if none is given
>>> defaultdest('foo')
'foo'
>>> defaultdest('/foo/bar')
'bar'
>>> defaultdest('/')
''
>>> defaultdest('')
''
>>> defaultdest('http://example.org/')
''
>>> defaultdest('http://example.org/foo/')
'foo'
"""
path = util.url(source).path
if not path:
return ""
return os.path.basename(os.path.normpath(path))
def _generic_start_transaction(handler, h, req):
tunnel_host = getattr(req, '_tunnel_host', None)
if tunnel_host:
if tunnel_host[:7] not in ['http://', 'https:/']:
tunnel_host = 'https://' + tunnel_host
new_tunnel = True
else:
tunnel_host = req.get_selector()
new_tunnel = False
if new_tunnel or tunnel_host == req.get_full_url(): # has proxy
u = util.url(tunnel_host)
if new_tunnel or u.scheme == 'https': # only use CONNECT for HTTPS
h.realhostport = ':'.join([u.host, (u.port or '443')])
h.headers = req.headers.copy()
h.headers.update(handler.parent.addheaders)
return
h.realhostport = None
h.headers = None
def defaultdest(source):
'''return default destination of clone if none is given
>>> defaultdest('foo')
'foo'
>>> defaultdest('/foo/bar')
'bar'
>>> defaultdest('/')
''
>>> defaultdest('')
''
>>> defaultdest('http://example.org/')
''
>>> defaultdest('http://example.org/foo/')
'foo'
'''
path = util.url(source).path
if not path:
return ''
return os.path.basename(os.path.normpath(path))
def _generic_start_transaction(handler, h, req):
tunnel_host = getattr(req, '_tunnel_host', None)
if tunnel_host:
if tunnel_host[:7] not in ['http://', 'https:/']:
tunnel_host = 'https://' + tunnel_host
new_tunnel = True
else:
tunnel_host = req.get_selector()
new_tunnel = False
if new_tunnel or tunnel_host == req.get_full_url(): # has proxy
u = util.url(tunnel_host)
if new_tunnel or u.scheme == 'https': # only use CONNECT for HTTPS
h.realhostport = ':'.join([u.host, (u.port or '443')])
h.headers = req.headers.copy()
h.headers.update(handler.parent.addheaders)
return
h.realhostport = None
h.headers = None
def find_user_password(self, realm, authuri):
authinfo = urllib2.HTTPPasswordMgrWithDefaultRealm.find_user_password(
self, realm, authuri)
user, passwd = authinfo
if user and passwd:
self._writedebug(user, passwd)
return (user, passwd)
if not user or not passwd:
res = httpconnectionmod.readauthforuri(self.ui, authuri, user)
if res:
group, auth = res
user, passwd = auth.get('username'), auth.get('password')
self.ui.debug("using auth.%s.* for authentication\n" % group)
if not user or not passwd:
u = util.url(authuri)
u.query = None
if not self.ui.interactive():
raise util.Abort(
_('http authorization required for %s') %
util.hidepassword(str(u)))
self.ui.write(
_("http authorization required for %s\n") %
util.hidepassword(str(u)))
self.ui.write(_("realm: %s\n") % realm)
if user:
self.ui.write(_("user: %s\n") % user)
else:
user = self.ui.prompt(_("user:"), default=None)
if not passwd:
passwd = self.ui.getpass()
self.add_password(realm, authuri, user, passwd)
self._writedebug(user, passwd)
return (user, passwd)
def handleremotechangegroup(op, inpart):
"""apply a bundle10 on the repo, given an url and validation information
All the information about the remote bundle to import are given as
parameters. The parameters include:
- url: the url to the bundle10.
- size: the bundle10 file size. It is used to validate what was
retrieved by the client matches the server knowledge about the bundle.
- digests: a space separated list of the digest types provided as
parameters.
- digest:<digest-type>: the hexadecimal representation of the digest with
that name. Like the size, it is used to validate what was retrieved by
the client matches what the server knows about the bundle.
When multiple digest types are given, all of them are checked.
"""
try:
raw_url = inpart.params['url']
except KeyError:
raise util.Abort(_('remote-changegroup: missing "%s" param') % 'url')
parsed_url = util.url(raw_url)
if parsed_url.scheme not in capabilities['b2x:remote-changegroup']:
raise util.Abort(
_('remote-changegroup does not support %s urls') %
parsed_url.scheme)
try:
size = int(inpart.params['size'])
except ValueError:
raise util.Abort(
_('remote-changegroup: invalid value for param "%s"') % 'size')
except KeyError:
raise util.Abort(_('remote-changegroup: missing "%s" param') % 'size')
digests = {}
for typ in inpart.params.get('digests', '').split():
param = 'digest:%s' % typ
try:
value = inpart.params[param]
except KeyError:
raise util.Abort(
_('remote-changegroup: missing "%s" param') % param)
digests[typ] = value
real_part = util.digestchecker(url.open(op.ui, raw_url), size, digests)
# Make sure we trigger a transaction creation
#
# The addchangegroup function will get a transaction object by itself, but
# we need to make sure we trigger the creation of a transaction object used
# for the whole processing scope.
op.gettransaction()
import exchange
cg = exchange.readbundle(op.repo.ui, real_part, raw_url)
if not isinstance(cg, changegroup.cg1unpacker):
raise util.Abort(
_('%s: not a bundle version 1.0') % util.hidepassword(raw_url))
ret = changegroup.addchangegroup(op.repo, cg, 'bundle2', 'bundle2')
op.records.add('changegroup', {'return': ret})
if op.reply is not None:
# This is definitly not the final form of this
# return. But one need to start somewhere.
part = op.reply.newpart('b2x:reply:changegroup')
part.addparam('in-reply-to', str(inpart.id), mandatory=False)
part.addparam('return', '%i' % ret, mandatory=False)
try:
real_part.validate()
except util.Abort, e:
raise util.Abort(
_('bundle at %s is corrupted:\n%s') %
(util.hidepassword(raw_url), str(e)))
def defaultdest(source):
'''return default destination of clone if none is given'''
return os.path.basename(os.path.normpath(util.url(source).path or ''))
elif srcrepo:
exchange.push(srcrepo,
destpeer,
revs=revs,
bookmarks=srcrepo._bookmarks.keys())
else:
raise util.Abort(
_("clone from remote to remote not supported"))
cleandir = None
destrepo = destpeer.local()
if destrepo:
template = uimod.samplehgrcs['cloned']
fp = destrepo.vfs("hgrc", "w", text=True)
u = util.url(abspath)
u.passwd = None
defaulturl = str(u)
fp.write(template % defaulturl)
fp.close()
destrepo.ui.setconfig('paths', 'default', defaulturl, 'clone')
if update:
if update is not True:
checkout = srcpeer.lookup(update)
uprev = None
status = None
if checkout is not None:
try:
uprev = destrepo.lookup(checkout)
def module(self, module, *path, **kwargs):
global moduleschanged
#If we are not performing an action on a module just going to its page
if not path:
pages.require("/admin/modules.view")
return pages.get_template("modules/module.html").render(
module=ActiveModules[module], name=module)
else:
#This gets the interface to add a page
if path[0] == 'addresource':
#path[1] tells what type of resource is being created and addResourceDispatcher returns the appropriate crud screen
return addResourceDispatcher(module, path[1])
#This case handles the POST request from the new resource target
if path[0] == 'addresourcetarget':
return addResourceTarget(module, path[1], kwargs['name'],
kwargs)
#This case shows the information and editing page for one resource
if path[0] == 'resource':
return resourceEditPage(module, path[1])
#This goes to a dispatcher that takes into account the type of resource and updates everything about the resource.
if path[0] == 'updateresource':
return resourceUpdateTarget(module, path[1], kwargs)
#This returns a page to delete any resource by name
if path[0] == 'deleteresource':
pages.require("/admin/modules.edit")
return pages.get_template(
"modules/deleteresource.html").render(module=module)
#This handles the POST request to actually do the deletion
if path[0] == 'deleteresourcetarget':
pages.require("/admin/modules.edit")
moduleschanged = True
with modulesLock:
r = ActiveModules[module].pop(kwargs['name'])
if r['resource-type'] == 'page':
usrpages.removeOnePage(module, kwargs['name'])
#Annoying bookkeeping crap to get rid of the cached crap
if r['resource-type'] == 'event':
newevt.removeOneEvent(module, kwargs['name'])
if r['resource-type'] == 'permission':
auth.importPermissionsFromModules(
) #sync auth's list of permissions
messagebus.postMessage(
"/system/notifications",
"User " + pages.getAcessingUser() + " deleted resource " +
kwargs['name'] + " from module " + module)
raise cherrypy.HTTPRedirect('/modules')
#This is the target used to change the name and description(basic info) of a module
if path[0] == 'update':
pages.require("/admin/modules.edit")
moduleschanged = True
with modulesLock:
ActiveModules[module]['__description']['text'] = kwargs[
'description']
ActiveModules[kwargs['name']] = ActiveModules.pop(module)
#UHHG. So very much code tht just syncs data structures.
#This gets rid of the cache under the old name
newevt.removeModuleEvents(module)
usrpages.removeModulePages(module)
#And calls this function the generate the new cache
bookkeeponemodule(kwargs['name'])
#Just for fun, we should probably also sync the permissions
auth.importPermissionsFromModules()
raise cherrypy.HTTPRedirect('/modules/module/' +
util.url(kwargs['name']))
def url(s):
return util.url(s)
raise util.Abort(
_("bad subrepository pattern in %s: %s") %
(p.source('subpaths', pattern), e))
return src
state = {}
for path, src in p[''].items():
kind = 'hg'
if src.startswith('['):
if ']' not in src:
raise util.Abort(_('missing ] in subrepo source'))
kind, src = src.split(']', 1)
kind = kind[1:]
src = src.lstrip() # strip any extra whitespace after ']'
if not util.url(src).isabs():
parent = _abssource(ctx._repo, abort=False)
if parent:
parent = util.url(parent)
parent.path = posixpath.join(parent.path or '', src)
parent.path = posixpath.normpath(parent.path)
joined = str(parent)
# Remap the full joined path and use it if it changes,
# else remap the original source.
remapped = remap(joined)
if remapped == joined:
src = remap(src)
else:
src = remapped
src = remap(src)
def clone(ui, peeropts, source, dest=None, pull=False, rev=None,
update=True, stream=False, branch=None):
"""Make a copy of an existing repository.
Create a copy of an existing repository in a new directory. The
source and destination are URLs, as passed to the repository
function. Returns a pair of repository peers, the source and
newly created destination.
The location of the source is added to the new repository's
.hg/hgrc file, as the default to be used for future pulls and
pushes.
If an exception is raised, the partly cloned/updated destination
repository will be deleted.
Arguments:
source: repository object or URL
dest: URL of destination repository to create (defaults to base
name of source repository)
pull: always pull from source repository, even in local case or if the
server prefers streaming
stream: stream raw data uncompressed from repository (fast over
LAN, slow over WAN)
rev: revision to clone up to (implies pull=True)
update: update working directory after clone completes, if
destination is local repository (True means update to default rev,
anything else is treated as a revision)
branch: branches to clone
"""
if isinstance(source, str):
origsource = ui.expandpath(source)
source, branch = parseurl(origsource, branch)
srcpeer = peer(ui, peeropts, source)
else:
srcpeer = source.peer() # in case we were called with a localrepo
branch = (None, branch or [])
origsource = source = srcpeer.url()
rev, checkout = addbranchrevs(srcpeer, srcpeer, branch, rev)
if dest is None:
dest = defaultdest(source)
if dest:
ui.status(_("destination directory: %s\n") % dest)
else:
dest = ui.expandpath(dest)
dest = util.urllocalpath(dest)
source = util.urllocalpath(source)
if not dest:
raise util.Abort(_("empty destination path is not valid"))
destvfs = scmutil.vfs(dest, expandpath=True)
if destvfs.lexists():
if not destvfs.isdir():
raise util.Abort(_("destination '%s' already exists") % dest)
elif destvfs.listdir():
raise util.Abort(_("destination '%s' is not empty") % dest)
srclock = destlock = cleandir = None
srcrepo = srcpeer.local()
try:
abspath = origsource
if islocal(origsource):
abspath = os.path.abspath(util.urllocalpath(origsource))
if islocal(dest):
cleandir = dest
copy = False
if (srcrepo and srcrepo.cancopy() and islocal(dest)
and not phases.hassecret(srcrepo)):
copy = not pull and not rev
if copy:
try:
# we use a lock here because if we race with commit, we
# can end up with extra data in the cloned revlogs that's
# not pointed to by changesets, thus causing verify to
# fail
srclock = srcrepo.lock(wait=False)
except error.LockError:
copy = False
if copy:
srcrepo.hook('preoutgoing', throw=True, source='clone')
hgdir = os.path.realpath(os.path.join(dest, ".hg"))
if not os.path.exists(dest):
os.mkdir(dest)
else:
# only clean up directories we create ourselves
cleandir = hgdir
try:
destpath = hgdir
util.makedir(destpath, notindexed=True)
except OSError as inst:
if inst.errno == errno.EEXIST:
cleandir = None
raise util.Abort(_("destination '%s' already exists")
% dest)
raise
destlock = copystore(ui, srcrepo, destpath)
# copy bookmarks over
srcbookmarks = srcrepo.join('bookmarks')
dstbookmarks = os.path.join(destpath, 'bookmarks')
if os.path.exists(srcbookmarks):
util.copyfile(srcbookmarks, dstbookmarks)
# Recomputing branch cache might be slow on big repos,
# so just copy it
def copybranchcache(fname):
srcbranchcache = srcrepo.join('cache/%s' % fname)
dstbranchcache = os.path.join(dstcachedir, fname)
if os.path.exists(srcbranchcache):
if not os.path.exists(dstcachedir):
os.mkdir(dstcachedir)
util.copyfile(srcbranchcache, dstbranchcache)
dstcachedir = os.path.join(destpath, 'cache')
# In local clones we're copying all nodes, not just served
# ones. Therefore copy all branch caches over.
copybranchcache('branch2')
for cachename in repoview.filtertable:
copybranchcache('branch2-%s' % cachename)
# we need to re-init the repo after manually copying the data
# into it
destpeer = peer(srcrepo, peeropts, dest)
srcrepo.hook('outgoing', source='clone',
node=node.hex(node.nullid))
else:
try:
destpeer = peer(srcrepo or ui, peeropts, dest, create=True)
# only pass ui when no srcrepo
except OSError as inst:
if inst.errno == errno.EEXIST:
cleandir = None
raise util.Abort(_("destination '%s' already exists")
% dest)
raise
revs = None
if rev:
if not srcpeer.capable('lookup'):
raise util.Abort(_("src repository does not support "
"revision lookup and so doesn't "
"support clone by revision"))
revs = [srcpeer.lookup(r) for r in rev]
checkout = revs[0]
if destpeer.local():
if not stream:
if pull:
stream = False
else:
stream = None
destpeer.local().clone(srcpeer, heads=revs, stream=stream)
elif srcrepo:
exchange.push(srcrepo, destpeer, revs=revs,
bookmarks=srcrepo._bookmarks.keys())
else:
raise util.Abort(_("clone from remote to remote not supported"))
cleandir = None
destrepo = destpeer.local()
if destrepo:
template = uimod.samplehgrcs['cloned']
fp = destrepo.vfs("hgrc", "w", text=True)
u = util.url(abspath)
u.passwd = None
defaulturl = str(u)
fp.write(template % defaulturl)
fp.close()
destrepo.ui.setconfig('paths', 'default', defaulturl, 'clone')
if update:
if update is not True:
checkout = srcpeer.lookup(update)
uprev = None
status = None
if checkout is not None:
try:
uprev = destrepo.lookup(checkout)
except error.RepoLookupError:
pass
if uprev is None:
try:
uprev = destrepo._bookmarks['@']
update = '@'
bn = destrepo[uprev].branch()
if bn == 'default':
status = _("updating to bookmark @\n")
else:
status = (_("updating to bookmark @ on branch %s\n")
% bn)
except KeyError:
try:
uprev = destrepo.branchtip('default')
except error.RepoLookupError:
uprev = destrepo.lookup('tip')
if not status:
bn = destrepo[uprev].branch()
status = _("updating to branch %s\n") % bn
destrepo.ui.status(status)
_update(destrepo, uprev)
if update in destrepo._bookmarks:
bookmarks.activate(destrepo, update)
finally:
release(srclock, destlock)
if cleandir is not None:
shutil.rmtree(cleandir, True)
if srcpeer is not None:
srcpeer.close()
return srcpeer, destpeer
