init git project

+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+bin/
+build/
+develop-eggs/
+dist/
+eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.cache
+nosetests.xml
+coverage.xml
+
+# Translations
+*.mo
+
+# Mr Developer
+.mr.developer.cfg
+.project
+.pydevproject
+
+# Rope
+.ropeproject
+
+# Django stuff:
+*.log
+*.pot
+
+# Sphinx documentation
+docs/_build/
+
+.idea/
+
+
+.settings/
+
+*.iml
+
+# certificates
+*.cer
+*.pem
+
+*guacamole.properties
+*config.py
+*.rb~
+*.erb~
+*.json~
+*.py~
+*.txt~
+*.log~
+*.log.*

+# based_Flask
+personal learning flask framework 
+
+Make a summary of personal Flask framework Usage to build out an whole WebServer Example.
+Including Sqlalchemy 

+
+#apt-get install libmysqlclient-dev
+
+werkzeug==0.9.6
+flask==0.10.1
+flask-restful==0.2.12
+flask-cors==1.9.0
+sqlalchemy
+flask-sqlalchemy
+mysql-python
+wsgilog
+requests
+apscheduler
+mock==1.0.1
+python-dateutil
+pytz
+validictory
+beaker

+# -*- coding: utf-8 -*-
+
+from server import app
+
+if __name__ == "__main__":
+    app.run(host='0.0.0.0', port=80)

+# -*- coding: utf-8 -*-
+
+__author__ = 'hubian'
+
+from flask import Flask
+from flask_restful import Api
+
+
+# initialize flask and flask restful
+app = Flask(__name__)
+app.config['SECRET_KEY'] = "myNameIsHuBian"
+app.debug = True
+
+api = Api(app)
+
+from utils import init_factory
+init_factory()
+
+from views import init_routes
+init_routes()

+# -*- coding: utf-8 -*-
+
+__author__ = 'hubian'
+
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import scoped_session, sessionmaker
+from sqlalchemy.ext.declarative import declarative_base
+from db_adapters import SQLAlchemyAdapter
+
+
+engine = create_engine('mysql://root:123456@localhost/sunnycloud',
+                       convert_unicode=True,
+                       pool_size=50,
+                       max_overflow=100,
+                       echo=False)
+db_session = scoped_session(sessionmaker(autocommit=False,
+                                         autoflush=True,
+                                         bind=engine))
+Base = declarative_base()
+Base.query = db_session.query_property()
+db_adapter = SQLAlchemyAdapter(db_session)
+
+from models import *
\ No newline at end of file

+# -*- coding: utf-8 -*-
+
+__author__ = 'hubian'
+
+class SQLAlchemyAdapterMetaClass(type):
+    @staticmethod
+    def wrap(func):
+        """Return a wrapped instance method"""
+
+        def auto_commit(self, *args, **kwargs):
+            try:
+                # todo a trick for DB transaction issue
+                # self.commit()
+                return_value = func(self, *args, **kwargs)
+                self.commit()
+                return return_value
+            except:
+                self.rollback()
+                raise
+
+        return auto_commit
+
+    def __new__(cls, name, bases, attrs):
+        """If the method in this list, DON'T wrap it"""
+        no_wrap = ["commit", "merge", "rollback", "remove", "session"]
+
+        def wrap(method):
+            """private methods are not wrapped"""
+            if method not in no_wrap and not method.startswith("__"):
+                attrs[method] = cls.wrap(attrs[method])
+
+        map(lambda m: wrap(m), attrs.keys())
+        return super(SQLAlchemyAdapterMetaClass, cls).__new__(cls, name, bases, attrs)
+
+
+class DBAdapter(object):
+    def __init__(self, db_session):
+        self.db_session = db_session
+
+
+class SQLAlchemyAdapter(DBAdapter):
+    """Use MetaClass to make this class"""
+    __metaclass__ = SQLAlchemyAdapterMetaClass
+
+    def __init__(self, db_session):
+        super(SQLAlchemyAdapter, self).__init__(db_session)
+
+    # ------------------------------ methods that no need to wrap --- start ------------------------------
+
+    def commit(self):
+        self.db_session.commit()
+
+    def remove(self):
+        self.db_session.remove()
+
+    def merge(self, obj):
+        self.db_session.merge(obj)
+
+    def rollback(self):
+        self.db_session.rollback()
+
+    def session(self):
+        return self.db_session
+
+    # ------------------------------ methods that no need to wrap --- end------------------------------
+
+    # ------------------------------ auto wrapped 'public' methods  --- start ------------------------------
+    def get_object(self, ObjectClass, id):
+        """ Retrieve one object specified by the primary key 'pk' """
+        return ObjectClass.query.get(id)
+
+    def find_all_objects(self, ObjectClass, *criterion):
+        return ObjectClass.query.filter(*criterion).all()
+
+    def find_all_objects_by(self, ObjectClass, **kwargs):
+        return ObjectClass.query.filter_by(**kwargs).all()
+
+    def find_all_objects_order_by(self, ObjectClass, limit=None, *order_by, **kwargs):
+        if limit is not None:
+            return ObjectClass.query.filter_by(**kwargs).order_by(*order_by).limit(limit)
+        else:
+            return ObjectClass.query.filter_by(**kwargs).order_by(*order_by).all()
+
+    def count(self, ObjectClass, *criterion):
+        return ObjectClass.query.filter(*criterion).count()
+
+    def count_by(self, ObjectClass, **kwargs):
+        return ObjectClass.query.filter_by(**kwargs).count()
+
+    def find_first_object(self, ObjectClass, *criterion):
+        return ObjectClass.query.filter(*criterion).first()
+
+    def find_first_object_by(self, ObjectClass, **kwargs):
+        return ObjectClass.query.filter_by(**kwargs).first()
+
+
+    def add_object(self, inst):
+        self.db_session.add(inst)
+
+    def add_object_kwargs(self, ObjectClass, **kwargs):
+        """ Add an object of class 'ObjectClass' with fields and values specified in '**kwargs'. """
+        object = ObjectClass(**kwargs)
+        self.db_session.add(object)
+        return object
+
+    def update_object(self, object, **kwargs):
+        """ Update object 'object' with the fields and values specified in '**kwargs'. """
+        for key, value in kwargs.items():
+            if hasattr(object, key):
+                setattr(object, key, value)
+            else:
+                raise KeyError("Object '%s' has no field '%s'." % (type(object), key))
+
+    def delete_object(self, instance):
+        """ Delete object 'object'. """
+        self.db_session.delete(instance)
+
+    def delete_all_objects(self, ObjectClass, *criterion):
+        ObjectClass.query.filter(*criterion).delete(synchronize_session=False)
+
+    def delete_all_objects_by(self, ObjectClass, **kwargs):
+        """ Delete all objects matching the case sensitive filters in 'kwargs'. """
+
+        # Convert each name/value pair in 'kwargs' into a filter
+        query = ObjectClass.query.filter_by(**kwargs)
+
+        # query filter by in_ do not support none args, use synchronize_session=False instead
+        return query.delete(synchronize_session=False)
+
+        # ------------------------------ auto wrapped 'public' methods  --- end ------------------------------

+# -*- coding: utf-8 -*-
+
+__author__ = 'hubian'
+
+import json
+from . import Base, db_adapter
+from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, Text, TypeDecorator
+from sqlalchemy.orm import relation, backref
+
+
+def relationship(*arg, **kw):
+    ret = relation(*arg, **kw)
+    db_adapter.commit()
+    return ret
+
+
+def to_dic(inst, cls):
+    # add your coversions for things like datetime's
+    # and what-not that aren't serializable.
+    convert = dict()
+    # convert[TZDateTime] = date_serializer
+
+    d = dict()
+    for c in cls.__table__.columns:
+        v = getattr(inst, c.name)
+        if c.type.__class__ in convert.keys() and v is not None:
+            try:
+                func = convert[c.type.__class__]
+                d[c.name] = func(v)
+            except:
+                d[c.name] = "Error:  Failed to covert using ", str(convert[c.type.__class__])
+        else:
+            d[c.name] = v
+    return d
+
+
+def to_json(inst, cls):
+    return json.dumps(to_dic(inst, cls))
+
+
+class DBBase(Base):
+    """
+    DB model base class, providing basic functions
+    """
+    __abstract__ = True
+
+    def __init__(self, **kwargs):
+        super(DBBase, self).__init__(**kwargs)
+
+    def dic(self):
+        return to_dic(self, self.__class__)
+
+    def json(self):
+        return to_json(self, self.__class__)
+
+    def __repr__(self):
+        return '%s: %s' % (self.__class__.__name__, self.json())
+
+
+class Host(DBBase):
+    __tablename__ = 'host'
+
+    id = Column(Integer, primary_key=True)
+    hostname = Column(String(50), unique=True, nullable=False)
+    public_ip = Column(String(50), unique=True, nullable=False)
+    private_ip = Column(String(50), unique=True, nullable=False)
+    mem = Column(String(50), nullable=False)
+    cores = Column(Integer, nullable=False)
+    disk = Column(String(50), nullable=False)
+    create_time = Column(DateTime, nullable=False)
+    update_time = Column(DateTime)
+
+
+class VM(DBBase):
+    __tablename__ = 'vm'
+
+    id = Column(Integer, primary_key=True)
+    vm_name = Column(String(50), unique=True, nullable=False)
+    os_type = Column(String(50), nullable=False)  # constants 0:linux 1:windows
+    cores = Column(Integer, nullable=False)
+    mem = Column(String(50), nullable=False)
+    capacity_g = Column(Integer, nullable=False)
+    config = Column(String(50))
+    user = Column(String(50), nullable=False)
+    create_time = Column(DateTime, nullable=False)
+    update_time = Column(DateTime)
+
+    image_id = Column(Integer, ForeignKey('image.id', ondelete='CASCADE'))
+    image = relationship('Image', backref=backref('images_vms', lazy='dynamic'))
+
+    host_id = Column(Integer, ForeignKey('host.id', ondelete='CASCADE'))
+    host = relationship('Host', backref=backref('host_vms', lazy='dynamic'))
+
+
+class Network(DBBase):
+    __tablename__ = "network"
+
+    id = Column(Integer, primary_key=True)
+    mac = Column(String(50), unique=True, nullable=False)
+    type = Column(String(50), nullable=False)  # constants 0:public 1:private
+    address = Column(String(50), unique=True, nullable=False)
+    device = Column(String(50), nullable=False)
+    create_time = Column(DateTime, nullable=False)
+    update_time = Column(DateTime)
+
+    vm_id = Column(Integer, ForeignKey('vm.id', ondelete='CASCADE'))
+    vm = relationship('VM', backref=backref('networks', lazy='dynamic'))
+
+
+class Disk(DBBase):
+    __tablename__ = "disk"
+
+    id = Column(Integer, primary_key=True)
+    type = Column(Integer, nullable=True)  # constants 0:system 1:mounted
+    capacity_g = Column(Integer, nullable=False)
+    format = Column(Integer, nullable=False)  # constants 0:ntfs 1:ext4
+    path = Column(String(50), unique=True, nullable=False)
+    create_time = Column(DateTime, nullable=False)
+    update_time = Column(DateTime)
+
+    vm_id = Column(Integer, ForeignKey('vm.id', ondelete='CASCADE'))
+    vm = relationship('VM', backref=backref('disks', lazy='dynamic'))
+
+
+class Image(DBBase):
+    __tablename__ = "image"
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String(50), unique=True, nullable=False)
+    type = Column(Integer, nullable=True)  # constants 0:default 1:provide 2:customize
+    path = Column(String(50), unique=True, nullable=False)
+    create_by = Column(String(50))
+    create_time = Column(DateTime, nullable=False)
+    update_time = Column(DateTime)

+# -*- coding: utf-8 -*-
+
+__author__ = 'hubian'
+

+# -*- coding: utf-8 -*-
+
+__author__ = 'hubian'
+
+from server.database import Base, engine
+from server.database.models import Host
+from server.database import db_adapter
+
+
+def setup_db():
+    """Initialize db tables
+
+    make sure database and user correctly created in mysql
+    in case upgrade the table structure, the origin table need be dropped firstly
+    """
+    Base.metadata.create_all(bind=engine)
+
+    # init REQUIRED db data.
+    db_adapter.add_object_kwargs(Host,
+                                 id='1',
+                                 hostname='test1',
+                                 public_ip='10.0.2.15',
+                                 private_ip='127.0.0.1',
+                                 mem='32G',
+                                 cores=16
+                                 )
+setup_db()

+# -*- coding: utf-8 -*-
+
+__author__ = 'hubian'
+
+from utils import Utils
+from log import Log
+from factory import factory
+from server.database import db_session
+from server.database.db_adapters import SQLAlchemyAdapter
+
+def init_factory():
+    factory.provide("util", Utils)
+    factory.provide("log", Log)
+    factory.provide("db", SQLAlchemyAdapter, db_session)
+

+# -*- coding: utf-8 -*-
+
+__author__ = 'hubian'
+
+
+class VM:
+    OS_TYPE_LINUX = 0
+    OS_TYPE_WINDOWS = 1
+
+
+class NETWORK:
+    IP_TYPE_PUBLIC = 0
+    IP_TYPE_PRIVATE = 1
+
+
+class DISK:
+    TYPE_SYSTEM = 0
+    TYPE_MOUNTED = 1
+
+    FORMAT_NTFS = 0
+    FORMAT_EXT4 = 1
+
+
+class IMAGE:
+    TYPE_DEFAULT = 0  # Router or Monitor
+    TYPE_PROVIDER = 1  # vm images type
+    TYPE_CUSTOMIZE = 2   # created by users

+# -*- coding: utf-8 -*-
+
+__author__ = 'hubian'
+
+
+class SunnycloudFactory:
+    def __init__(self, allow_replace=False):
+        """Create a new factory
+
+        :param allow_replace: whether to replace existing provider with same feature. AssertionException will be raised it's
+        False and more than one providers with same key(feature) are provided
+        """
+        self.providers = {}
+        self.allow_replace = allow_replace
+
+    def set_allow_replace(self, allow_replace):
+        """Set the value of allow_replace"""
+        self.allow_replace = allow_replace
+
+    def provide(self, feature, provider, *args, **kwargs):
+        """Add a provider to factory
+
+        :type feature: str|unicode
+        :param feature: key to store and get the object into/from the factory
+
+        :type provider: object | callable
+        :param provider: the object to be added.
+
+        :Example:
+            from *** import VMManager
+            factory.provide("vm_manager", VMManager)
+            factory.provide("vm_manager", VMManager, *init_args, **init_kwargs)
+
+            # or:
+            vmm = VMManager
+            factory.provide("user_manager", vmm)
+
+        """
+        if not self.allow_replace:
+            assert not self.providers.has_key(feature), "Duplicate feature: %r" % feature
+        if callable(provider):
+            def call():
+                return provider(*args, **kwargs)
+        else:
+            def call():
+                return provider
+        self.providers[feature] = call
+
+    def __getitem__(self, feature):
+        try:
+            provider = self.providers[feature]
+        except KeyError:
+            raise KeyError, "Unknown feature named %r" % feature
+        return provider()
+
+
+factory = SunnycloudFactory()
+
+
+def NoAssertion(obj):
+    return True
+
+
+class RequiredFeature(object):
+    def __init__(self, feature, assertion=NoAssertion):
+        """Create instance of RequiredFeature.
+
+        Will get the actual target from factory upon the first call.
+
+        :type feature: str|unicode
+        :param feature: the key to get object from factory
+
+        :Example:
+            inst = RequiredFeature("user_manager")
+            inst.some_method() # where user_manager.some_method will be called
+
+        :raise:
+            KeyError if feature doesn't exist in factory.
+        """
+        self.feature = feature
+        self.assertion = assertion
+
+    def __get__(self, obj, T):
+        return self.result  # <-- will request the feature upon first call
+
+    def __getattr__(self, name):
+        self.result = self.request()
+        if name == "result":
+            return self.result
+        else:
+            return getattr(self.result, name)
+
+    def request(self):
+        obj = factory[self.feature]
+        assert self.assertion(obj), \
+            "The value %r of %r does not match the specified criteria" \
+            % (obj, self.feature)
+        return obj

+# -*- coding: utf-8 -*-
+
+__author__ = 'hubian'
+
+import logging
+from os.path import realpath, dirname
+from logging import config, DEBUG, INFO
+
+class Log(object):
+    """Wrapper of Python logging module for easier usage
+
+    :Example:
+        from hackathon.log import log
+
+        log.info("message of INFO level ")
+        log.error(exception) # where exception is of type Exception or it inheritances
+
+    .. notes:: make sure directory '/var/log/open-hackathon/' exists and accessible
+    """
+
+    def debug(self, debug):
+        """write message into log file with DEBUG level
+
+        :type debug: str|unicode
+        :param debug: message to write
+        """
+        if self.logger.isEnabledFor(DEBUG):
+            self.logger.debug(debug)
+
+    def info(self, info):
+        """write message into log file with INFO level
+
+        :type info: str|unicode
+        :param info: message to write
+        """
+        if self.logger.isEnabledFor(INFO):
+            self.logger.info(info)
+
+    def warn(self, warn):
+        """write message into log file with WARN level
+
+        :type warn: str|unicode
+        :param warn: message to write
+        """
+        self.logger.warn(warn)
+
+    def error(self, exception):
+        """write exception message and stack trace into log file with ERROR level
+
+        :type exception: Exception
+        :param exception: exception to write
+        """
+        self.logger.error(str(exception), exc_info=1)
+
+    def critical(self, critical):
+        """write message into log file with FATAL level
+
+        :type critical: str|unicode
+        :param critical: message to write
+        """
+        self.logger.critical(critical)
+
+    def __init__(self):
+        """initialize the log wrapper through 'logging.conf' file which should be in the same dir of this file"""
+        logging.config.fileConfig("%s/logging.conf" % dirname(realpath(__file__)))
+        self.logger = logging.getLogger("myLogger")
\ No newline at end of file

+#define logger, handler,formatter names.
+[loggers]
+keys=root,myLogger,sqlalchemy,sqlConPool
+
+[handlers]
+keys=consoleHandler,logHandler,sqlLogHandler
+
+[formatters]
+keys=myFormatter
+
+#define default logger
+[logger_root]
+level=DEBUG
+handlers=consoleHandler
+
+#define system wide logger
+[logger_myLogger]
+level=DEBUG
+handlers=consoleHandler,logHandler
+qualname=myLogger
+propagate=0
+
+#define sqlalchemy echo logger
+[logger_sqlalchemy]
+level=WARNING
+handlers=consoleHandler,sqlLogHandler
+qualname=sqlalchemy.engine
+propagate=0
+
+#define sqlalchemy connection pool logger
+[logger_sqlConPool]
+level=WARNING
+handlers=consoleHandler,sqlLogHandler
+qualname=sqlalchemy.pool
+propagate=0
+
+#define consoleHandler
+[handler_consoleHandler]
+class=StreamHandler
+level=DEBUG
+formatter=myFormatter
+args=(sys.stdout,)
+
+#define logHandler
+[handler_logHandler]
+class=logging.handlers.TimedRotatingFileHandler
+level=DEBUG
+formatter=myFormatter
+args=('/var/log/open-hackathon/sunnycloud.log','midnight',1,14)
+
+#define sqlLogHandler
+[handler_sqlLogHandler]
+class=logging.handlers.TimedRotatingFileHandler
+level=DEBUG
+formatter=myFormatter
+args=('/var/log/open-hackathon/sunnycloud.log','midnight',1,14)
+
+#define formatter
+[formatter_myFormatter]
+format=%(asctime)s - %(levelname)s(%(threadName)s) - %(message)s
+datefmt=
\ No newline at end of file

+# -*- coding: utf-8 -*-
+
+__author__ = 'hubian'
+
+from datetime import datetime
+
+
+class Utils():
+
+    def get_now(self):
+        return datetime.now()
+
+    def get_config(self):
+        return None
+
+    def get_safe_config(self):
+        return None
\ No newline at end of file

+# -*- coding: utf-8 -*-
+
+__author__ = 'hubian'
+
+from server import api
+from server.database import db_adapter
+from server.database.models import Host
+from flask_restful import Resource
+
+
+class TestResource(Resource):
+    def get(self):
+        return "server started"
+
+
+class HostResource(Resource):
+    def get(self):
+        return db_adapter.find_first_object_by(Host, id=1).dic()
+
+
+def init_routes():
+    api.add_resource(TestResource, "/api/test")
+    api.add_resource(HostResource, "/api/host")
+

+# -*- coding: utf-8 -*-
+
+__author__ = 'hubian'
+

+# -*- coding: utf-8 -*-
+
+__author__ = 'hubian'
+
+
+class VMManager():
+
+    def create_vm(self):
+        pass
+
+    def update_vm(self):
+        pass
+
+    def delete_vm(self):
+        pass
+
+    def get_vm_list(self):
+        pass
+
+    # ------------------------helper functions ---------------------- #
+
+    def __generate_vm_xml(self):
+        pass