django-restit 4.0.2__tar.gz → 4.0.5__tar.gz

{django_restit-4.0.2 → django_restit-4.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-restit
-Version: 4.0.2
+Version: 4.0.5
 Summary: A Rest Framework for DJANGO
 License: MIT
 Author: Ian Starnes

django_restit-4.0.5/pushit/rpc/__init__.py

@@ -0,0 +1,2 @@
+from .githooks import *  # noqa: F401, F403
+from .products import *  # noqa: F401, F403

django_restit-4.0.5/pushit/rpc/githooks.py

@@ -0,0 +1,61 @@
+from rest import decorators as rd
+from rest import views as rv
+from rest import settings
+from rest import helpers as rh
+from taskqueue.models import Task
+from pushit import utils
+import time
+
+
+@rd.urlPOST('hooks/git_update')
+def rest_on_git_hook(request):
+    sec_key = request.DATA.get("token")
+    git_key = settings.get("GIT_KEY", "hookswhat")
+    hook_request = None
+
+    req_key = request.DATA.getHeader("HTTP_X_GITLAB_TOKEN")
+    if req_key is not None:
+        hook_request = utils.parseGitLab(request)
+    else:
+        req_key = request.DATA.getHeader("HTTP_X_HUB_SIGNATURE_256")
+        if req_key is not None:
+            hook_request = utils.parseGithub(request)    
+
+    if sec_key != git_key and req_key is None:
+        rh.error("GIT HOOK NO TOKEN", request.META)
+        return rv.restPermissionDenied(request)
+
+    git_projects = settings.get("GIT_PROJECTS", None)
+
+    if hook_request.name not in git_projects:
+        return rv.restStatus(request, False, error="no config for project")
+
+    proj_info = utils.getProjectForBranch(git_projects.get(hook_request.name), hook_request.branch)
+    if proj_info is None:
+        return rv.restStatus(request, False, error="no branch for project")
+
+    if hook_request.kind == "push":
+        on_git_push_request(proj_info, hook_request)
+
+    return rv.restStatus(request, True)
+
+
+def on_git_push_request(info, hook_request):
+    branch = info.get("branch")
+    cmd = info.get("updater")
+    use_tq = info.get("use_tq", False)
+
+    if use_tq:
+        data = dict(branch=branch, update_cmd=cmd)
+        Task.Publish("pushit", "run_update", data, channel="tq_updater")
+    else:
+        asyncUpdater(cmd, branch)
+
+
+@rd.rest_async
+def asyncUpdater(cmd, branch):
+    import random
+    # randomize the hit so we avoid collisions (gitlabs issues)
+    time.sleep(random.randint(2, 15))
+    utils.updateCode(cmd, branch)
+

django_restit-4.0.5/pushit/rpc/legacy.py

@@ -0,0 +1,126 @@
+from pushit.models import Product, Release
+from rest import decorators as rd
+
+
+@rd.urlPOST (r'^product$')
+@rd.urlPOST (r'^product/(?P<product_id>\d+)$')
+@rd.urlPOST (r'^product/uuid/(?P<uuid>\w+)$')
+@rd.login_optional
+def updateProduct(request, product_id=None, uuid=None):
+    if not request.member:
+        return restPermissionDenied(request)
+    product = None
+    if not product_id and not uuid:
+        product = Product.createFromRequest(request, owner=request.member, group=request.group)
+    elif product_id:
+        product = Product.objects.filter(pk=product_id).last()
+    elif uuid:
+        product = Product.objects.filter(oid=uuid).last()
+
+    if not product:
+        return restStatus(request, False, error="unknown product")
+    if product.owner != request.member or (product.group and not request.member.isMemberOf(product.group)):
+        if not request.user.is_staff:
+            return restPermissionDenied(request)
+        product.saveFromRequest(request, owner=request.member)
+    return restGet(request, product, **Product.getGraph("default"))
+
+
+@rd.urlGET (r'^product/(?P<product_id>\d+)$')
+@rd.urlGET (r'^product/uuid/(?P<uuid>\w+)$')
+@rd.login_optional
+def getProduct(request, product_id=None, uuid=None):
+    product = None
+    if product_id:
+        product = Product.objects.filter(pk=product_id).last()
+    elif uuid:
+        product = Product.objects.filter(oid=uuid).last()
+    else:
+        return restNotFound(request)
+
+    if not product:
+        return restStatus(request, False, error="unknown product")
+    if not product.is_public and not request.member:
+        return restPermissionDenied(request, "not logged in")
+    return product.restGet(request)
+
+
+@rd.urlGET (r'^product$')
+@rd.login_optional
+def listProducts(request):
+    if not request.member:
+        return restPermissionDenied(request)
+    if not request.member.is_staff:
+        return restPermissionDenied(request)
+
+    kind = request.DATA.get("kind")
+    qset = Product.objects.filter(archived=False)
+    if kind:
+        qset = qset.filter(kind=kind)
+
+    return restList(request, qset, **Product.getGraph("default"))
+
+
+@rd.urlPOST (r'^release$')
+@rd.urlPOST (r'^release/(?P<release_id>\d+)$')
+@rd.login_optional
+def updateRelease(request, release_id=None):
+    if not request.member:
+        return restPermissionDenied(request)
+
+    if not release_id:
+        auto_version = request.DATA.get("auto_version", False)
+        prod_uuid = request.DATA.get(["product", "product_uuid"])
+        product = None
+        if prod_uuid:
+            product = Product.objects.filter(oid=prod_uuid).last()
+        else:
+            prod_id = request.DATA.get("product_id")
+            if prod_id:
+                product = Product.objects.filter(pk=prod_id).last()
+        if not product:
+            return restStatus(request, False, error="product required")
+        version_num = request.DATA.get("version_num", field_type=int)
+        last_release = Release.objects.filter(product=product).order_by("-version_num").first()
+
+        if not version_num:
+            if last_release and auto_version:
+                version_num = last_release.version_num + 1
+            elif auto_version:
+                version_num = 1
+            else:
+                return restStatus(request, False, error="no version info supplied, try auto_version=1")
+        elif last_release and version_num <= last_release.version_num:
+            return restStatus(request, False, error="version is not greater then last")
+
+        release = Release.createFromRequest(request, product=product, owner=request.member, group=request.group, version_num=version_num)
+    else:
+        release = Release.objects.filter(pk=release_id).last()
+        if not release:
+            return restStatus(request, False, error="unknown release")
+        if release.owner != request.member or (release.product.group and not request.member.isMemberOf(release.product.group)):
+            if not request.user.is_staff:
+                return restPermissionDenied(request)
+        release.saveFromRequest(request, owner=request.member)
+    if request.DATA.get("make_current"):
+        release.makeCurrent()
+    elif request.DATA.get("make_beta"):
+        release.makeCurrent()
+    return restGet(request, release, **Release.getGraph("default"))
+
+
+@rd.urlGET (r'^release/(?P<release_id>\d+)$')
+@rd.login_optional
+def getRelease(request, release_id):
+    release = Release.objects.filter(pk=release_id).last()
+    if not release:
+        return restStatus(request, False, error="unknown release")
+    if not release.product.is_public and not request.member:
+        return restPermissionDenied(request, "not logged in")
+    return restGet(request, release, **Release.getGraph("default"))
+
+
+def reportRestIssue(subject, message, perm="rest_errors", email_only=False):
+    # notifyWithPermission(perm, subject, message=None, template=None, context=None, email_only=False)
+    # notify email only
+    Member.notifyWithPermission(perm, subject, message, email_only=email_only)

django_restit-4.0.5/pushit/rpc/products.py

@@ -0,0 +1,15 @@
+from rest import decorators as rd
+from rest import views as rv
+from pushit.models import Product, Release
+
+
+@rd.url('product')
+@rd.url('product/<int:pk>')
+def rest_on_product(request, pk=None):
+    return Product.on_rest_request(request, pk)
+
+
+@rd.url('release')
+@rd.url('release/<int:pk>')
+def rest_on_release(request, pk=None):
+    return Release.on_rest_request(request, pk)

django_restit-4.0.5/pushit/tq.py

@@ -0,0 +1,6 @@
+from pushit import utils
+
+
+def run_update(task):
+    utils.run_update(task.data.update_cmd, task.data.branch)
+    task.completed()

django_restit-4.0.5/pushit/utils.py

@@ -0,0 +1,58 @@
+from rest import settings
+from rest import log
+from objict import objict
+import os
+import subprocess
+
+logger = log.getLogger("pushit", filename="pushit.log")
+
+
+def updateCode(update_cmd, branch, update_user="ec2-user"):
+    if settings.PUSHIT_TEST_SUDO:
+        cmd = ["sudo", "-lU", update_user, update_cmd, branch]
+        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        out, err = process.communicate()
+        if err.strip():
+            logger.warning("WARNING: cannot run {}, we don't have sudo rights".format(update_cmd))
+            logger.warning("WARNING: add {} to your sudo user".format(update_cmd))
+            return
+    # - lock it so we kill any updates in progress and start a new one
+    cmd = ["sudo", "-u", update_user, update_cmd, branch]
+    logger.info("updating...", cmd)
+    subprocess.Popen(cmd, close_fds=True)
+
+
+def parseGitLab(request):
+    info = objict(vendor="gitlab")
+    info.name = request.DATA.get("project.name")
+    info.kind = request.DATA.get("object_kind")
+    if "ref" in request.DATA:
+        info.branch = request.DATA.get("ref").split('/')[-1]
+    if info.kind == "merge_request":
+        info.state = request.DATA.get("object_attributes.state", None)
+        if info.state == "merged":
+            info.kind = "merged"
+    return info
+
+
+def parseGithub(request):
+    info = objict(vendor="github")
+    info.name = request.DATA.get("repository.name")
+    info.kind = request.DATA.getHeader("HTTP_X_GITHUB_EVENT")
+    if "ref" in request.DATA:
+        info.branch = request.DATA.get("ref").split('/')[-1]
+    logger.info("github request", info)
+    return info
+
+
+def getProjectForBranch(proj_info, branch):
+    if proj_info is None:
+        return None
+    if isinstance(proj_info, list):
+        for pi in proj_info:
+            if pi["branch"] == branch:
+                return pi
+        return None
+    if proj_info["branch"] == branch:
+        return proj_info
+    return None

{django_restit-4.0.2 → django_restit-4.0.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-restit"
-version = "4.0.2"
+version = "4.0.5"
 description = "A Rest Framework for DJANGO"
 authors = ["Ian Starnes <ians@311labs.com>"]
 license = "MIT"
@@ -53,20 +53,17 @@ django-redis-sessions = "^0.6.2"
 
 [tool.poetry.group.dev.dependencies]
 twine = "^4.0.2"
-bumpver = "^2023.1124"
 
 [tool.bumpver]
-current_version = "4.0.0"
+current_version = "4.0.3"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = false
 tag = true
 push = true
 
-[tool.bumpver.file_patterns]
-"pyproject.toml" = [
-    'current_version = "{version}"',
-]
+[tool.poetry_bumpversion.file."rest/__init__.py"]
+
 
 [build-system]
 requires = ["poetry-core"]

{django_restit-4.0.2 → django_restit-4.0.5}/rest/__init__.py

@@ -1,4 +1,4 @@
 from .uberdict import UberDict  # noqa: F401
 from .settings_helper import settings  # noqa: F401
 
-__version__ = "5.4.0"
+__version__ = "4.0.5"

{django_restit-4.0.2 → django_restit-4.0.5}/rest/decorators.py

@@ -18,12 +18,14 @@ from datetime import datetime
 from auditlog.models import PersistentLog
 
 import importlib
+import pkgutil
 import threading
 import traceback
 
 REST_METRICS = settings.get("REST_METRICS", False)
 REST_METRICS_BY_ENDPOINT = settings.get("REST_METRICS_BY_ENDPOINT", False)
 REST_METRICS_IGNORE = settings.get("REST_METRICS_IGNORE", [])
+REST_MODULE_NAME = settings.get("REST_MODULE_NAME", "rpc")
 
 
 # background task (no return)
@@ -130,6 +132,12 @@ def dispatcher(request, *args, **kwargs):
     return restStatus(request, False, error="endpoint not found", error_code=404)
 
 
+def _load_module(mod):
+    if pkgutil.find_loader(mod) is not None:
+        return importlib.import_module(mod)
+    return None
+
+
 def _url_method(pattern, method=None, *args, **kwargs):
     """
     Register a view handler for a specific HTTP method
@@ -150,13 +158,17 @@ def _url_method(pattern, method=None, *args, **kwargs):
                 # print module.__name__
                 root_name = module.__name__.split('.')[0]
                 # print "importing {0}.rpc".format(root_name)
-                rpc_root_module = importlib.import_module(root_name + ".rpc")
+                rmodule = _load_module(f"{root_name}.{REST_MODULE_NAME}")
+                if rmodule is not None:
+                    rpc_root_module = rmodule
             # print "{0}/{1}".format(rpc_root_module.__name__, pattern)
-            elif not module.__name__.endswith(".rpc") and module.__name__.count('.'):
+            elif not module.__name__.endswith(f".{REST_MODULE_NAME}") and module.__name__.count('.'):
                 # print module.__name__
                 root_name = module.__name__.split('.')[0]
                 # print "importing {0}.rpc".format(root_name)
-                rpc_root_module = importlib.import_module(root_name + ".rpc")
+                rmodule = _load_module(f"{root_name}.{REST_MODULE_NAME}")
+                if rmodule is not None:
+                    rpc_root_module = rmodule
             lmethod = method
             if lmethod is None:
                 lmethod = "ALL"

{django_restit-4.0.2 → django_restit-4.0.5}/rest/log.py

@@ -12,7 +12,11 @@ import sys
 import threading
 import time
 import traceback
+from .settings_helper import settings
 
+LOG_FOLDER = settings.LOG_ROOT
+if LOG_FOLDER is None:
+    LOG_FOLDER = os.path.join(settings.BASE_DIR, "var", "logs")
 
 COLOR_LOGS = True
 MAX_LOG_SIZE = 10485760
@@ -21,19 +25,6 @@ MAX_LOG_SIZE = 10485760
 ROTATE_LEFT_OVER_BYTES = 50000
 LOG_COUNT = 3
 
-REST_FOLDER = os.path.realpath(__file__)
-# now work backwards until we find folder with "django"
-ROOT = None
-CUR_FOLDER = REST_FOLDER
-while ROOT is None:
-    if os.path.exists(os.path.join(CUR_FOLDER, "django")):
-        ROOT = CUR_FOLDER
-    else:
-        CUR_FOLDER = os.path.dirname(CUR_FOLDER)
-
-VAR_FOLDER = os.path.join(ROOT, "var", "logs")
-PATH = VAR_FOLDER
-
 
 class RestLogManager(object):
     def __init__(self):
@@ -121,8 +112,8 @@ def getLogger(
         LOG_MANAGER.loggers[name] = rest_logger
         if set_master:
             LOG_MANAGER.master = rest_logger
-        if not os.path.exists(VAR_FOLDER):
-            mkdir(VAR_FOLDER)
+        if not os.path.exists(LOG_FOLDER):
+            mkdir(LOG_FOLDER)
     except Exception as err:
         print((str(err)))
         print((str(traceback.format_exc())))
@@ -160,7 +151,7 @@ class RestLoggerStream(object):
                 if not os.path.exists(self.filename):
                     path, fname = os.path.split(filename)
                     if not len(path):
-                        self.filename = os.path.join(VAR_FOLDER, filename)
+                        self.filename = os.path.join(LOG_FOLDER, filename)
         self.max_bytes = max_bytes
         self.stream = None
         self.is_stdout = False

{django_restit-4.0.2 → django_restit-4.0.5}/rest/rpc.py

@@ -31,6 +31,13 @@ def on_get_version(request):
     return views.restStatus(request, True, {"data": version.VERSION})
 
 
+@url(r'^versions$')
+def on_get_version(request):
+    from rest import __version__ as restit_version
+    versions = dict(project=version.VERSION, restit=restit_version)
+    return views.restStatus(request, True, {"data": versions})
+
+
 @url(r'^joke$')
 def on_get_joke(request):
     return views.restGet(request, {"joke": joke.getRandomJoke()})

{django_restit-4.0.2 → django_restit-4.0.5}/rest/urls.py

@@ -24,7 +24,9 @@ urlpatterns = [
 def load_app(app, root_module=None):
     module = None
     try:
-        module = loadModule(app + '.rpc')
+        module = loadModule(f"{app}.rpc")
+        if module is None:
+            module = loadModule(f"{app}.rurl")
     except ImportError as err:
         print("**** failed to load {0}.rpc! ****".format(app))
         print("**** missing dependencies ****")