import os

user_id = "vm001"

drv = os.path.join("C:\\", "vm_disks")

for file in os.listdir(os.path.join(drv, user_id, "Virtual Machines")):

    if file.endswith(".xml"):

        vm_id = os.path.splitext(file)[0]

        disk_dir = os.path.join(drv, user_id, "Virtual Hard Disks")

        for disk_file in os.listdir(disk_dir):

            if disk_file.endswith(".vhd"):

                cmd = "icacls \"%s\" /grant \"NT VIRTUAL MACHINE\\%s\":(F)" % (os.path.join(disk_dir, disk_file), vm_id)

                print cmd

                res = os.popen(cmd).read()

                print res

import os

import errno

from win32com.client import GetObject

class PIDLockError(Exception):

    pass

class AlreadyLocked(PIDLockError):

    def __init__(self, path):

        self.path = path

    def __str__(self):

        return "%s is already locked" % self.path

class LockFailed(PIDLockError):

    def __init__(self, path):

        self.path = path

    def __str__(self):

        return "failed to create %s" % self.path

class PIDLockFile(object):

    def __init__(self, path):

        self.path = path

    def read_pid(self):

        return self.read_pid_from_pidfile()

    def is_locked(self):

        return os.path.exists(self.path)

    def i_am_locking(self):

        running_process = []

        wmi = GetObject('winmgmts:')

        processes = wmi.InstancesOf('win32_Process')

        for pro in processes:

            running_process.append(pro.Properties_('ProcessId').value)

        if self.is_locked():

            if self.read_pid() in running_process:

                return True

        return False

    def acquire(self):

        if not self.i_am_locking():

            self.break_lock()

        try:

            self.write_pid_to_pidfile()

        except OSError, exc:

            if exc.errno == errno.EEXIST:

                raise AlreadyLocked(self.path)

            else:

                raise LockFailed(self.path)

        else:

            return

    def release(self):

        self.remove_existing_pidfile()

    def break_lock(self):

        self.remove_existing_pidfile()

    def read_pid_from_pidfile(self):

        pid = None

        try:

            pidfile = open(self.path, 'r')

        except IOError:

            pass

        else:

            line = pidfile.readline().strip()

            try:

                pid = int(line)

            except ValueError:

                pass

            pidfile.close()

        return pid

    def write_pid_to_pidfile(self):

        pidfile_fd = os.open(self.path, os.O_CREAT | os.O_EXCL | os.O_WRONLY)

        pidfile = os.fdopen(pidfile_fd, 'w')

        pid = os.getpid()

        pidfile.write("%s\n" % pid)

        pidfile.close()        

    def remove_existing_pidfile(self):

        if self.is_locked(): os.remove(self.path) 

# example

import os

import traceback

import pidlockfile import PIDLockFile, PIDLockError

def main():

    pid_file = os.path.join("C:\\", "run", "run.pid")

    plock = PIDLockFile(pid_file)

    try:

        plock.acquire()

        print "hellow" 

        plock.release()

    except PIDLockError, exc:

        print exc

    except Exception, exc:

        print traceback.format_exc()

if __name__ == "__main__":

    main()

# exec 3<>/dev/tcp/mx4.naver.com/25

# RESPONSE="`cat <&3`"

# echo "Response is: $RESPONSE"

Response is: 220 mx.naver.com ESMTP uhOoOzccQ6eHbxMheoMwfA - nsmtp

451 4.4.2 Timeout - closing connection uhOoOzccQ6eHbxMheoMwfA - nsmtp

# exec 3<>/dev/tcp/mx4.naver.com/25

# RESPONSE="`cat <&3`"

# echo "Response is: $RESPONSE"

Response is: 421 4.3.2 Your ip blocked from this server O8n3JcaPR-SkE+jwsts6GA - nsmtp 

if [[ "$RESPONS" =~ "blocked" ]]; then

    echo "blocked"

else

    echo "ok"

fi

#!/home/python2.7/bin/python

# -*- coding: UTF-8 -*-

import sys

import time

from daemon.runner import DaemonRunner

sys.path.append("/home/package_manager/lib")

class App(object):

    def __init__(self):

        self.stdin_path = "/dev/null"

        self.stdout_path = "/dev/tty"

        self.stderr_path = "/dev/tty"

        self.pidfile_timeout = 0

        self.pidfile_path = "/home/package_manager/run/app.pid"

    def run(self):

        from database import session

        from models import APMDistributionQueue

        while 1:

            tasks = session.query(APMDistributionQueue).all()

            for task in tasks:

                print task.server_info.hostn

            time.sleep(10)

def main():

    DaemonRunner(App()).do_action()

if __name__ == "__main__":

    main() 

 # -*- coding: UTF-8 -*-

from sqlalchemy import create_engine

from sqlalchemy.orm import scoped_session, sessionmaker

from sqlalchemy.ext.declarative import declarative_base

engine = create_engine('mysql+mysqldb://아이디:비밀번호@localhost/manager_new', convert_unicode=True)

Base = declarative_base()

session = scoped_session(sessionmaker(autocommit=False, autoflush=False, bind=engine))

# -*- coding: UTF-8 -*-

from sqlalchemy.sql import func

from sqlalchemy import ForeignKey, Column, Integer, String, DateTime, Table

from sqlalchemy.orm import relationship, backref

from database import Base, engine

class ServerInfo(Base):

       __table__ = Table('info', Base.metadata, autoload=True, autoload_with=engine)

class APMPackage(Base):

    __tablename__ = 'apm_package'

    id = Column(Integer, primary_key=True)

    name = Column(String(100), unique=True)

    packaging_file = Column(String(200))

    unpackaging_path = Column(String(200))

    queue = relationship("APMDistributionQueue", backref=backref('package'), cascade='all, delete, delete-orphan')

    def __init__(self, name, file, path):

        self.name = name

        self.packaging_file = file

        self.unpackaging_path = path

    def __repr__(self):

        return "%s %s %s %s" % (self.id, self.name, self.packaging_file, self.unpackaging_path)

class APMDistributionQueue(Base):

    __tablename__ = 'apm_distribution_queue'

    id = Column(Integer, primary_key=True)

    mode = Column(String(20), nullable=False)

    server_id = Column(Integer, ForeignKey(ServerInfo.idx), nullable=False)

    package_id = Column(Integer, ForeignKey(APMPackage.id), nullable=False)

    status = Column(Integer, default=1, nullable=False)

    reg_date = Column(DateTime(timezone=True), default=func.now(), nullable=False)

    server_info = relationship("ServerInfo", backref=backref('queue'))

    def __init__(self, mode, sid, pid):

        self.mode = mode

        self.server_id = sid

        self.package_id = pid

    def __repr__(self):

        return "%s %s %s %s" % (self.id, self.mode, self.server_id, self.package_id)