shadowsocks-manager 0.1.1__py3-none-any.whl

shadowsocks_manager/__main__.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+import os
+import sys
+import subprocess
+from docopt import docopt
+
+
+def main():
+    """
+    Description:
+        Make the proxy call after adding the django root to the python path and changing the current directory to the django root.
+
+    Usage:
+        ssm COMMAND [OPTIONS]
+
+    Options:
+        COMMAND     The command to be run.
+        OPTIONS     All options are transparently passing to the called command.
+
+    Returns:
+        None
+
+    Example:
+        $ ssm python manage.py runserver
+        $ ssm uwsgi --ini uwsgi.ini
+        $ ssm celery -A shadowsocks_manager worker -l info
+    """
+    #docopt(main.__doc__)
+
+    django_root = os.path.dirname(os.path.abspath(__file__))
+
+    # add the django root to the python path to allow django commands to be run from any directory
+    if django_root not in sys.path:
+        sys.path.insert(0, django_root)
+
+    # change dir to the django root to allow the dir-sensitive commands(such as loaddata) to be run from any directory
+    os.chdir(django_root)
+
+ 
+    # make the proxy call
+    return subprocess.call(sys.argv[1:])
+
+
+if __name__ == '__main__':
+    sys.exit(main())

shadowsocks_manager/args_formatter/__init__.py

@@ -0,0 +1,74 @@
+# py2.7 and py3 compatibility imports
+from __future__ import unicode_literals
+from builtins import range
+from builtins import object
+from functools import reduce
+
+
+class Formatter(object):
+    """
+    Return the input-syntax string presentation of args and kwargs list, delimited by comma `, `.
+    The value of the args and kwargs are formatted as the canonical string presentation.
+
+    Usage:
+        >>> f = Formatter(*args, **kwargs)
+        >>> print(f)
+
+    Example:
+        >>> print(Formatter('foo', 1, x='bar', y=2))
+        'foo', 1, x='bar', y=2
+
+    Use Case:
+        # log the input arguments of methods.
+        def foo(*args, **kwargs):
+            message = Formatter(*args, **kwargs).to_string())
+            logger.debug('foo: {}'.format(message))
+    """
+
+    def __init__(self, *args, **kwargs):
+        """
+        Initialize the Formatter to have two members: args, kwargs
+        """
+        self.args = args
+        self.kwargs = kwargs
+
+    def __str__(self, *args, **kwargs):
+        return self.to_string(*args, **kwargs)
+
+    def args_to_string(self):
+        """
+        Return the canonical string presentation of args list, delimited by comma `, `.
+        """
+        if self.args:
+            self.args = [repr(arg) for arg in self.args]
+            formatter = ['{}' for count in range(len(self.args))]
+            return ', '.join(formatter).format(*self.args)
+
+
+    def kwargs_to_string(self):
+        """
+        Return the input-syntax string presentation of kwargs list, delimited by comma `, `.
+        The value of the kwargs are formatted as the canonical string presentation.
+        """
+        if self.kwargs:
+            formatter = ['{}={}' for count in range(len(self.kwargs))]
+            return ', '.join(formatter).format(
+                *reduce((lambda x, y: x + y), [list([k, repr(v)]) for k,v in list(self.kwargs.items())]))
+
+    def to_string(self):
+        """
+        Return the input-syntax string presentation of args and kwargs list, delimited by comma `, `.
+        The value of the args and kwargs are formatted as the canonical string presentation.
+        Be noted to the differences:
+            * An empty string `` is returned if no args and kwargs found.
+            * The input empty string `` is returned as the literal "``" with the additional quoting.
+            * The input NoneType None is returned as the literal `None` without additional quoting.
+
+        Example:
+            >>> Formatter('foo', 1, x='bar', y=2).to_string()
+            "'foo', 1, x='bar', y=2"
+        """
+
+        items = [self.args_to_string(), self.kwargs_to_string()]
+        items = [item for item in items if item is not None]
+        return ', '.join(items)

shadowsocks_manager/args_formatter/tests.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+
+# py2.7 and py3 compatibility imports
+from __future__ import unicode_literals
+from __future__ import absolute_import
+from builtins import str
+
+from unittest import TestCase
+
+from . import Formatter
+
+# Create your tests here.
+class FormatterTestCase(TestCase):
+    def test(self):
+        # no args and kwargs
+        self.assertEqual(Formatter().to_string(), '')
+        # one arg as None
+        self.assertEqual(Formatter(None).to_string(), 'None')
+        # one arg as empty string
+        self.assertEqual(Formatter('').to_string(), repr(''))
+        # two simple args
+        self.assertEqual(Formatter('foo', 1).to_string(), '{}, 1'.format(repr('foo')))
+        # one arg as list
+        self.assertEqual(Formatter(['foo', 1]).to_string(), '[{}, 1]'.format(repr('foo')))
+        # one arg as dict
+        self.assertEqual(Formatter({'foo': 1}).to_string(), repr({'foo': 1}))
+        # on arg as tuple
+        self.assertEqual(Formatter(('foo', 1)).to_string(), repr(('foo', 1)))
+        # two simple kwargs, take care of the order, so works with both py2 and py3
+        self.assertEqual(Formatter(y=2, x='bar').to_string(), 'y=2, x={}'.format(repr('bar')))
+        # one kwarg as list
+        self.assertEqual(Formatter(x=['bar', 2]).to_string(), 'x={}'.format(repr(['bar', 2])))
+        # one kwarg as dict
+        self.assertEqual(Formatter(x={'bar': 2}).to_string(), 'x={}'.format(repr({'bar': 2})))
+        # one kwarg as tuple
+        self.assertEqual(Formatter(x=('bar', 2)).to_string(), 'x={}'.format(repr(('bar', 2))))
+        # two simple args and two simple kwargs, take care of the order, so works with both py2 and py3
+        self.assertEqual(
+            Formatter('foo', 1, y=2, x='bar').to_string(),
+            '{}, 1, y=2, x={}'.format(repr('foo'), repr('bar')))
+        # __str__()
+        self.assertEqual(str(Formatter(None)), 'None')

shadowsocks_manager/domain/admin.py

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+
+# py2.7 and py3 compatibility imports
+from __future__ import unicode_literals
+
+import json
+from django.contrib import admin, messages
+
+from .models import NameServer, Domain, Record
+
+
+# Register your models here.
+
+@admin.register(NameServer)
+class NameServerAdmin(admin.ModelAdmin):
+    fields = ('name', 'api_cls_name', 'user', 'credential',
+                  'dt_created', 'dt_updated')
+
+    readonly_fields = ('dt_created', 'dt_updated')
+
+    list_display = ('name', 'api_cls_name', 'user', 'is_api_accessible',
+                        'dt_created', 'dt_updated')
+
+    def is_api_accessible(self, obj):
+        return obj.is_api_accessible
+
+    is_api_accessible.boolean = True
+    is_api_accessible.short_description = 'API'
+
+
+@admin.register(Domain)
+class DomainAdmin(admin.ModelAdmin):
+    fields = ('name', 'nameserver',
+                  'dt_created', 'dt_updated')
+
+    readonly_fields = ('dt_created', 'dt_updated')
+
+    list_display = ('name', 'nameserver',
+                        'dt_created', 'dt_updated')
+
+
+@admin.register(Record)
+class RecordAdmin(admin.ModelAdmin):
+    fields = ('host', 'domain', 'type', 'answer', 'site',
+                  'dt_created', 'dt_updated')
+
+    readonly_fields = ('dt_created', 'dt_updated')
+
+    list_display = ('host', 'domain', 'type', 'answer', 'answer_from_dns_api', 'is_matching_dns_api',
+                        'answer_from_dns_query', 'is_matching_dns_query', 'site',
+                        'dt_created', 'dt_updated')
+
+    def answer_from_dns_api(self, obj):
+        return list(obj.answer_from_dns_api) if obj.answer_from_dns_api is not None else obj.answer_from_dns_api
+
+    def answer_from_dns_query(self, obj):
+        return list(obj.answer_from_dns_query) if obj.answer_from_dns_query is not None else obj.answer_from_dns_query
+
+    def is_matching_dns_api(self, obj):
+        return obj.is_matching_dns_api
+
+    is_matching_dns_api.boolean = True
+    is_matching_dns_api.short_description = 'DNS API'
+
+    def is_matching_dns_query(self, obj):
+        return obj.is_matching_dns_query
+
+    is_matching_dns_query.boolean = True
+    is_matching_dns_query.short_description = 'DNS Query'
+
+    def sync_to_dns(self, request, queryset):
+        for obj in queryset:
+            result = obj.sync_to_dns()
+            messages.info(request, '{0}: {1}'.format(obj.host, json.dumps(result)))
+
+    sync_to_dns.short_description = 'Synchronize DNS records to DNS server for Selected Domain'
+
+    actions = (sync_to_dns,)

shadowsocks_manager/domain/apps.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+
+# py2.7 and py3 compatibility imports
+from __future__ import unicode_literals
+
+from django.apps import AppConfig
+
+
+class DomainConfig(AppConfig):
+    name = 'domain'

shadowsocks_manager/domain/migrations/0001_initial.py

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.11.29 on 2024-04-21 20:23
+from __future__ import unicode_literals
+
+import django.contrib.sites.models
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('sites', '0002_alter_domain_unique'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Domain',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(help_text='Root domain name. Example: yourdomain.com.', max_length=64, unique=True)),
+                ('dt_created', models.DateTimeField(auto_now_add=True, verbose_name='Created')),
+                ('dt_updated', models.DateTimeField(auto_now=True, verbose_name='Updated')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='NameServer',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(help_text='The name for the Nameserver, name it as your wish. Example: name.com.', max_length=64, unique=True)),
+                ('api_cls_name', models.CharField(choices=[('NameNsApi', 'NameNsApi')], help_text='Select the API class name for the Nameserver.', max_length=32, verbose_name='API Class')),
+                ('user', models.CharField(blank=True, help_text='User identity for the Nameserver API service.', max_length=64, null=True)),
+                ('credential', models.CharField(blank=True, help_text='User credential/token for the Nameserver API service.', max_length=128, null=True)),
+                ('dt_created', models.DateTimeField(auto_now_add=True, verbose_name='Created')),
+                ('dt_updated', models.DateTimeField(auto_now=True, verbose_name='Updated')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='Record',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('host', models.CharField(help_text='Host name. Example: vpn.', max_length=64)),
+                ('type', models.CharField(blank=True, choices=[('A', 'A'), ('MX', 'MX'), ('CNAME', 'CNAME'), ('TXT', 'TXT'), ('SRV', 'SRV'), ('AAAA', 'AAAA'), ('NS', 'NS'), ('ANAME', 'ANAME')], max_length=8, null=True)),
+                ('answer', models.CharField(blank=True, help_text='Answer for the host name, comma "," is the delimiter for multiple answers.', max_length=512, null=True)),
+                ('dt_created', models.DateTimeField(auto_now_add=True, verbose_name='Created')),
+                ('dt_updated', models.DateTimeField(auto_now=True, verbose_name='Updated')),
+                ('domain', models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, to='domain.Domain')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='Site',
+            fields=[
+            ],
+            options={
+                'proxy': True,
+                'indexes': [],
+            },
+            bases=('sites.site',),
+            managers=[
+                ('objects', django.contrib.sites.models.SiteManager()),
+            ],
+        ),
+        migrations.AddField(
+            model_name='record',
+            name='site',
+            field=models.ForeignKey(blank=True, help_text="The record with a site will be dynamically added to Django's ALLOWED_HOSTS.", null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='records', to='domain.Site'),
+        ),
+        migrations.AddField(
+            model_name='domain',
+            name='nameserver',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='domain.NameServer'),
+        ),
+        migrations.AlterUniqueTogether(
+            name='record',
+            unique_together=set([('host', 'domain')]),
+        ),
+    ]

shadowsocks_manager/domain/models.py

@@ -0,0 +1,265 @@
+# -*- coding: utf-8 -*-
+
+# py2.7 and py3 compatibility imports
+from __future__ import unicode_literals
+
+import logging
+import socket, requests, json
+from collections import defaultdict
+from django.db import models
+from django.db.models.signals import post_save, post_delete
+from django.dispatch import receiver
+from django.contrib.sites.models import Site
+from django.conf import settings
+
+
+logger = logging.getLogger('django')
+
+
+# Create your models here.
+
+class Site(Site):
+
+    class Meta:
+        proxy = True
+
+    def __str__(self):
+        return self.name
+
+
+class BaseNsApi(object):
+
+    def __init__(self, user, credential, *args, **kwargs):
+        super(BaseNsApi, self).__init__(*args, **kwargs)
+        self.user = user
+        self.credential = credential
+
+    def call_api(self, url, method='get', data=None):
+        response = getattr(requests, method)(
+            url,
+            auth=(self.user, self.credential),
+            json=data
+        )
+        return response.json()
+
+    def create_record(self, *args, **kwargs):
+        pass
+
+    def list_records(self, *args, **kwargs):
+        pass
+
+    def delete_records(self, *args, **kwargs):
+        pass
+
+
+class NameNsApi(BaseNsApi):
+
+    api_base_url = 'https://api.name.com/v4'
+
+    def create_record(self, domain, type, host, answer, ttl=300):
+        url = "/".join([self.api_base_url, 'domains', domain, 'records'])
+        data = {"host": host, "type": type, "answer": answer, "ttl": ttl}
+
+        return self.call_api(url, method='post', data=data)
+
+    def list_records(self, domain, type, host):
+        url = "/".join([self.api_base_url, 'domains', domain, 'records'])
+
+        records = self.call_api(url, method='get') or {}
+        return [item for item in records.get('records', [])
+                   if item.get('type') == type and item.get('host') == host]
+
+    def delete_records(self, domain, type, host):
+        records = self.list_records(domain, type, host)
+
+        for item in records:
+            url = "/".join([self.api_base_url, 'domains', domain, 'records', str(item.get('id'))])
+            self.call_api(url, method='delete')
+
+        return records
+
+    @property
+    def is_accessible(self):
+        try:
+            url = "/".join([self.api_base_url, 'hello'])
+            return self.call_api(url, method='get').get('username') == self.user
+        except:
+            return False
+
+
+class NameServer(models.Model):
+    API_CLASS_NAME = [
+        ('NameNsApi', 'NameNsApi')
+    ]
+
+    name = models.CharField(unique=True, max_length=64,
+        help_text='The name for the Nameserver, name it as your wish. Example: name.com.')
+    api_cls_name = models.CharField('API Class', max_length=32, choices=API_CLASS_NAME,
+        help_text='Select the API class name for the Nameserver.')
+    user = models.CharField(max_length=64, null=True, blank=True,
+        help_text='User identity for the Nameserver API service.')
+    credential = models.CharField(max_length=128, null=True, blank=True,
+        help_text='User credential/token for the Nameserver API service.')
+    dt_created = models.DateTimeField('Created', auto_now_add=True)
+    dt_updated = models.DateTimeField('Updated', auto_now=True)
+
+    def __str__(self):
+        return self.name
+
+    def __init__(self, *args, **kwargs):
+        super(NameServer, self).__init__(*args, **kwargs)
+
+        self.api_cls = globals().get(self.api_cls_name)
+
+    @property
+    def api(self):
+        if self.api_cls and self.user and self.credential:
+            return self.api_cls(self.user, self.credential)
+
+    @property
+    def is_api_accessible(self):
+        return self.api.is_accessible if self.api else None
+
+
+class Domain(models.Model):
+    name = models.CharField(unique=True, max_length=64,
+        help_text='Root domain name. Example: yourdomain.com.')
+    nameserver = models.ForeignKey(NameServer, null=True, blank=True, on_delete=models.SET_NULL)
+    dt_created = models.DateTimeField('Created', auto_now_add=True)
+    dt_updated = models.DateTimeField('Updated', auto_now=True)
+
+    def __str__(self):
+        return self.name
+
+    @property
+    def ns_api(self):
+        return self.nameserver.api if self.nameserver else None
+
+
+class Record(models.Model):
+    TYPE = [
+        ('A', 'A'),
+        ('MX', 'MX'),
+        ('CNAME', 'CNAME'),
+        ('TXT', 'TXT'),
+        ('SRV', 'SRV'),
+        ('AAAA', 'AAAA'),
+        ('NS', 'NS'),
+        ('ANAME', 'ANAME'),
+    ]
+
+    host = models.CharField(max_length=64,
+        help_text='Host name. Example: vpn.')
+    domain = models.ForeignKey(Domain, on_delete=models.PROTECT)
+    type = models.CharField(max_length=8, null=True, blank=True, choices=TYPE)
+    answer = models.CharField(max_length=512, null=True, blank=True,
+        help_text='Answer for the host name, comma "," is the delimiter for multiple answers.')
+    site = models.ForeignKey(Site, null=True, blank=True, on_delete=models.SET_NULL, related_name='records',
+        help_text="The record with a site will be dynamically added to Django's ALLOWED_HOSTS.")
+    dt_created = models.DateTimeField('Created', auto_now_add=True)
+    dt_updated = models.DateTimeField('Updated', auto_now=True)
+
+    class Meta:
+        unique_together = ('host', 'domain')
+
+    def __str__(self):
+        return self.fqdn
+
+    def save(self, *args, **kwargs):
+        super(Record, self).save(*args, **kwargs)
+        if self.site:
+            self.site.domain = self.fqdn
+            self.site.save()
+            settings.ALLOWED_HOSTS.update_cache()
+
+    @property
+    def fqdn(self):
+        return '.'.join([self.host, self.domain.name])
+
+    @property
+    def answers(self):
+        """
+        Return the record.answer in lowercase and split as Set.
+        """
+        return {
+            item.lower()
+            for item in (self.answer.split(',') if self.answer else [])
+        }
+
+    @property
+    def answer_from_dns_api(self):
+        """
+        Return the answers from DNS API, in lowercase and as Set.
+        """
+        if self.domain.ns_api:
+            return {
+                record.get('answer').lower()
+                for record in self.domain.ns_api.list_records(
+                    self.domain.name, self.type, self.host
+                )
+            }
+
+    @property
+    def answer_from_dns_query(self):
+        """
+        Return the answers from DNS query, in lowercase and as Set.
+        """
+        ips = []
+        try:
+            truename, alias, ips = socket.gethostbyname_ex(self.fqdn)
+        except socket.gaierror:
+            # not found the host
+            pass
+        except Exception as e:
+            logger.error(e)
+        return {item.lower() for item in ips}
+
+    @property
+    def is_matching_dns_api(self):
+        """
+        Test if the record.answer matches the DNS API query.
+        """
+        return self.answers == self.answer_from_dns_api
+
+    @property
+    def is_matching_dns_query(self):
+        """
+        Test if the record.answer matches the DNS query.
+        """
+        return self.answers == self.answer_from_dns_query
+
+    def sync_to_dns(self):
+        """
+        Sync the record to DNS server through DNS API.
+        """
+        ret = defaultdict(list)
+        if self.domain.ns_api:
+            if self.is_matching_dns_api:
+                ret['message'] = 'No need to synchronize.'
+                return ret
+
+            ret['deleted'] = self.delete_from_dns()
+            for answer in (self.answer or '').split(','):
+                ret['created'].append(
+                    self.domain.ns_api.create_record(self.domain.name, self.type, self.host, answer))
+        else:
+            ret['message'] = 'Please configure Nameserver and its User and Credential for the domain first.'
+
+        return ret
+
+    def delete_from_dns(self):
+        """
+        Delete the record from DNS server through DNS API.
+        """
+        if self.domain.ns_api:
+            return self.domain.ns_api.delete_records(self.domain.name, self.type, self.host)
+
+
+@receiver(post_save, sender=Record)
+def record_sync_to_dns(sender, instance, **kwargs):
+    instance.sync_to_dns()
+
+
+@receiver(post_delete, sender=Record)
+def record_delete_from_dns(sender, instance, **kwargs):
+    instance.delete_from_dns()

shadowsocks_manager/domain/serializers.py

@@ -0,0 +1,25 @@
+# py2.7 and py3 compatibility imports
+from __future__ import absolute_import
+from __future__ import unicode_literals
+
+from rest_framework import serializers
+
+from . import models
+
+
+class NameServerSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = models.NameServer
+        fields = ('id', 'name', 'api_cls_name', 'user', 'credential', 'dt_created', 'dt_updated')
+
+
+class DomainSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = models.Domain
+        fields = ('id', 'name', 'nameserver', 'dt_created', 'dt_updated')
+
+
+class RecordSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = models.Record
+        fields = ('id', 'host', 'domain', 'type', 'answer', 'site', 'dt_created', 'dt_updated')