Codes

原創 Romeo i 2019-08-23 00:42

server.cpp

#include "httplib.h"
#include <boost/filesystem.hpp>
#include <iostream>
#include <sstream>
#include <fstream>

#if 0
void HelloWorld(const httplib::Request &req, httplib::Response &rsp)
{
	//text/html 顯示在瀏覽器上的
	rsp.set_content("<html><h1>Hello World</h1></html>", "text/html");
}

int main()
{
	httplib::Server srv;
	//設置相對根目錄
	srv.set_base_dir("./www");
	//當客戶端發送get請求，該如何去處理
	//    192.168.43.85:9000/
	srv.Get("/", HelloWorld);
	srv.listen("0.0.0.0", 9000);
	return 0;

}
#endif

#define SERVER_BASE_DIR "www"
#define SERVER_ADDR "0.0.0.0"
#define SERVER_PORT 9000
#define SERVER_BACKUP_DIR SERVER_BASE_DIR"/list/"

using namespace httplib;
namespace bf = boost::filesystem;

class CloudServer{
private:
	httplib::Server srv;
public:
	CloudServer(){
		bf::path base_path(SERVER_BASE_DIR);
		//如果文件不存在
		if (!bf::exists(base_path)){
			//創建目錄
			bf::create_directory(base_path);
		}
		bf::path list_path(SERVER_BACKUP_DIR);
		if (!bf::exists(list_path)){
			bf::create_directory(list_path);
		}
	}
	bool Start(){
		srv.set_base_dir(SERVER_BASE_DIR);
		srv.Get("/(list(/){0,1}){0,1}", GetFileList);
		srv.Get("/list/(.*)", GetFileData);
		srv.Put("/list/(.*)", PutFileData);
		srv.listen("SERVER_ADDR", SERVER_PORT);
		return true;
	}
private:
	static void PutFileData(const Request &req, httplib::Response &rsp)
	{
		std::cout << "backup file " << req.path << "\n";
		if (!req.has_header("Range")){
			rsp.status = 400;
			return;
		}

			std::string range = req.get_header_value("Range");
			int64_t range_start;
			if (RangeParse(range, range_start) == false){
				rsp.status = 400;
				return;
			
		}
			std::string real = SERVER_BASE_DIR + req.path;
			std::ofstream file(real, std::ios::binary | std::ios::trunc);
			if (!file.is_open()){
				std::cerr << "open file " << real << "error\n";
				rsp.status = 500;
				return;
			}
			file.seekp(range_start, std::ios::beg);
			file.write(&req.body[0], req.body.size());
			if (!file.good()){
				std::cerr << "file write body error\n";
				rsp.status = 500;
				return;
			}
			file.close();
		return;
	}

	static bool RangeParse(std::string &range, int64_t &start){

		//Range: bytes=start-end
		size_t pos1 = range.find("=");
		size_t pos2 = range.find("=");
		if (pos1 == std::string::npos || pos2 == std::string::npos){
			std::cerr << "range:[" << range << "] format error\n";
			return false;
		}
		std::stringstream rs; 
		rs << range.substr(pos1 + 1, pos2 - pos1 - 1);
		rs >> start;
		return true;
	}
	//文件列表信息獲取,定義成靜態就是避免了this指針
	static void GetFileList(const Request &req, httplib::Response &rsp){
		bf::path list(SERVER_BACKUP_DIR);
		bf::directory_iterator item_begin(list);
		bf::directory_iterator item_end;

		std::string body;
		body = "<html><body><ol><hr />";



		for (; item_begin != item_end; ++item_begin){
			//如果不是目錄
			if (bf::is_directory(item_begin->status())){
				continue;
			}
			std::string file = item_begin->path().filename().string();
			std::string uri = "/list/" + file;
			body += "<h4><li>";
			body += "<a href='";
			body += uri;
			body += "'>";
			body += file;
			body += "</a>";
			body += "</li></h4>";
			//std::string file = item_begin->path().string();
			//std::cerr << "file:" << file << std::endl;
		}
		body += "<hr /></ol></body></html>";
		rsp.set_content(&body[0], "text/html");
		return;
	}
	//獲取文件數據（文件下載）
	static void GetFileData(const Request &req, httplib::Response &rsp){
		//req.path = "/list/a.txt";
		std::string file = SERVER_BACKUP_DIR + req.path;
		//文件不存在，page not found
		if (!bf::exists(file)){
			std::cerr << "file " << file << "is not exists\n";
			rsp.status = 404;
			return;
		}
		//文件存在
		//ifile = inputfile
		std::ifstream ifile(file, std::ios::binary);
		if (!ifile.is_open()){
			std::cerr << "open file " << file << "error\n";
			rsp.status = 500; //服務器內部錯誤
			return;
		}
		std::string body;
		//獲取文件大小
		int64_t fsize = bf::file_size(file);
		body.resize(fsize);
		ifile.read(&body[0], fsize);
		if (ifile.good()){
			std::cerr << "read file " << file << "body error\n";
			rsp.status = 500;
			return;
		}
		//正文只能給一次，文件不能太大
		rsp.set_content(body, "text/plain"); //plain文件下載
	}
	//解決文件上傳
	static void BackuoFile(const Request &req, httplib::Response &rsp){

	}


};

int main()
{
	CloudServer srv;
	srv.Start();
	return 0;
}

CloudClient.hpp

#define _D_SCL_SECURE_NO_WARNINGS 1
#ifndef __M_CLOUD_H__
#define __M_CLOUD_H__

#include <fstream>
#include <sstream>
#include <iostream>
#include <string>
#include <unordered_map>
#include <boost/filesystem.hpp>
#include <boost/algorithm/string.hpp>
#include <thread>
#include "httplib.h"

#define SERVER_IP "192.168.122.132"
#define SERVER_PORT 9000
#define CLIENT_BACKUP_DIR ".\\backup"
#define CLIENT_BACKUP_INFO_FILE ".\\back.list"
#define RANGE_MAX_SIZE (10 << 20) //10MB
#define BACKUP_URI "/list/"

namespace bf = boost::filesystem;

class ThrBackUp
{
private:
	std::string _file;
	int64_t _range_start;
	int64_t _range_len;
public:
	bool _res;
public:
	ThrBackUp(const std::string &file, int64_t start, int64_t len) :_res(true),
	_file(file), _range_start(start), _range_len(len) {}
	void Start(){
		//獲取文件的range分塊數據
		std::stringstream ss;
		ss << "backup file" << _file << "range:[" << _range_start << "-" << _range_len << "\n";
		std::cout << ss.str();
		std::ifstream path(_file, std::ios::binary);
		if (!path.is_open()){
			std::cerr << "range backup file " << _file << "failed!\n";
			_res = false;
			return;
		}
		//跳轉到range的起始位置
		path.seekg(_range_start, std::ios::beg);//跳轉
		std::string body;
		
		body.resize(_range_len);
		//讀取文件中range分塊的文件數據
		path.read(&body[0], _range_len);
		if (!path.good()){
			std::cerr << "read file" << _file << " range data failed\n";
			_res = false;
			return;
		}
		path.close();
		//上傳range數據
		bf::path name(_file);
		//組織上傳的uri路徑  method url version
		//PUT /list/filename HTTP/1.1
		std::string url = BACKUP_URI + name.filename().string();//native  不要雙引號
		//實例化一個httplib的客戶端對象
		httplib::Client cli(SERVER_IP, SERVER_PORT);
		//定義HTTP請求頭信息
		httplib::Headers hdr;
		hdr.insert(std::make_pair("Content-Length", std::to_string(_range_len)));

		std::stringstream tmp;
		tmp << "bytes=" << _range_start << "-" << _range_start + _range_len - 1;
		hdr.insert(std::make_pair("Range", tmp.str().c_str()));
		//通過實例化的Client向服務端發送PUT請求
		auto rsp = cli.Put(url.c_str(), hdr, body, "text/plain");
		if (rsp &&rsp->status != 200){
			_res = false;
		}
		else {
			std::stringstream ss;
			ss << "backup file" << _file << "] range:[" << _range_start << "-" << _range_len << "] backup success\n";
			std::cout << ss.str();
			return;
		}
		//return ;
	}
};
class CloudClient
{
public:
	CloudClient(){
		bf::path file(CLIENT_BACKUP_DIR);
		if (!bf::exists(file)){
			bf::create_directory(file);
		}
	}
private:
	std::unordered_map<std::string, std::string> _backup_list;
	//CloudClient(){}
private:
	
	//獲取備份信息
	bool GetBackupInfo()
	{
		//filename1 etag\n
		//filename2 etag\n
		//實例化path對象
		bf::path path(CLIENT_BACKUP_INFO_FILE);
		if (!bf::exists(path)){
			std::cerr << "list file" << path.string() << "is not exists\n";
			return false;
		}
		int64_t fsize = bf::file_size(path);
		if (fsize == 0){
			std::cerr << "have no backup info\n";
			return false;
		}
		std::string body;
		body.resize(fsize);
		std::ifstream file(CLIENT_BACKUP_INFO_FILE, std::ios::binary);
		if (!file.is_open()){
			std::cerr << "list file open error\n";
			return false;
		}
		file.read(&body[0], fsize);
		if (!file.good()){
			std::cerr << "read list file body error\n";
			return false;
		}
		file.close();
		std::vector<std::string> list;
		boost::split(list, body, boost::is_any_of("\n"));//切割後放到list中

		for (auto i : list){
			//filename2 etag
			size_t pos = i.find(" ");
			if (pos == std::string::npos)
				continue;
			std::string key = i.substr(0, pos);
			std::string val = i.substr(pos + 1);
			_backup_list[key] = val;
		}
		return true;
	}
	//將備份信息保存在指定文件中
	bool SetBackuoInfo()
	{
		std::string body;
		for (auto i : _backup_list){
			body += i.first + " " + i.second + "\n";
		}
		std::ofstream file(CLIENT_BACKUP_INFO_FILE, std::ios::binary);
		if (!file.is_open()){
			std::cerr << "open list file error\n";
			return false;
		}
		file.write(&body[0], body.size());
		if (!file.good()){
			std::cerr << "set backuo info error\n";
			return false;
		}
		file.close();
		return true;
	}
	//目錄監控
	bool BackupDirListen(const std::string &path)
	{
		bf::directory_iterator item_begin(path);
		bf::directory_iterator item_end;
		for (; item_begin != item_end; ++item_begin){
			// /list/abc/abc.txt bc.txt
			if (bf::is_directory(item_begin->status())){
				BackupDirListen(item_begin->path().string());
				continue;
			}
			if (FileIsNeedBackup(item_begin->path().string()) == false){
				continue;
			}
			std::cerr << "file:[" << item_begin->path().string() << "need backup\n";
			if (PutFileData(item_begin->path().string()) == false){
				continue;
			}
			//上傳成功後
			//記錄文件Etag信息
			AddBackInfo(item_begin->path().string());

		}
		return true;
	}

	//添加一個信息
	bool AddBackInfo(const std::string &file)
	{
		//etag = "mtime-fsize"
		std::string etag;
		if (GetFileEtag(file, etag) == false)
			return false;
		_backup_list[file] = etag;
	}
	static void thr_start(ThrBackUp *backuo_info){
		/*

		*/
		return;
	}

	//備份文件
	bool PutFileData(const std::string &file)
	{
		//按大小對文件內容進行分塊傳輸（10MB）
		//通過獲取分塊傳輸是否成功判斷整個文件是否上傳成功
		//選擇多線程處理
		//1.獲取文件大小
		int64_t fsize = bf::file_size(file);
		if (fsize <= 0){
			std::cerr << "file " << file << "unnecessary backup\n";
			return false;
		}
		//2.計算總共需要分多少塊，得到每塊大小以及起始位置
		//3.循環創建線程，在線程中上傳文件數據
		int count = (int)fsize / RANGE_MAX_SIZE;
		std::vector<ThrBackUp>thr_res;
		std::vector<std::thread> thr_list;
		std::cerr << "file:[" << file << "]fsize:[" << fsize << "] count:[" << count + 1 << "]\n";
		// fsize = 500;
		for (int i = 0; i <= count; ++i){
			int64_t range_start = i * RANGE_MAX_SIZE; //起始位置
			int64_t range_end = (i + 1) * RANGE_MAX_SIZE - 1;
			if (i == count-1){
				range_end += (fsize % RANGE_MAX_SIZE);
			}
			int64_t range_len = range_end - range_start + 1;
			ThrBackUp backup_info(file, range_start, range_len);
			std::cerr << "file:[" << file << "] range:[" << range_start << "-" << range_end << "]-" << range_len << "\n";
			thr_res.push_back(backup_info);
			thr_list.push_back(std::thread(thr_start, &thr_res[i]));
			//std::thread thr(thr_start, file, range_start, range_len, &thr_res[i]);

		}
		/*for (int i = 0; i <= count; ++i)
		{
			thr_list.push_back(std::thread(thr_start, &thr_res[i]));
		}*/

		//4.等待所有線程退出，判斷文件上傳結果
		bool ret = true;
		for (int i = 0; i <= count; ++i){
			thr_list[i].join();
			if (thr_res[i]._res == true)
				continue;
		}	
		ret = false;
		//5.上傳成功，則添加文件的備份信息記錄。 native() //不要雙引號
		if (ret == false){
			return false;
		}
			//AddBackInfo(file);
			std::cerr << "file:[" << file << "] backup success\n";
			return true;
	}
	
	bool FileIsNeedBackup(const std::string &file)
	{
		std::string etag;
		if (GetFileEtag(file, etag) == false)
			return false;
		auto it = _backup_list.find(file);
		if (it != _backup_list.end() && it->second == etag){
			//不需要備份
			return false;
		}
		
		return true;
	}
	bool GetFileEtag(const std::string &file, std::string &etag)
	{
		bf::path path(file);
		if (!bf::exists(path))
		{
			std::cerr << "get file" << file << "etag error\n";
			return false;
		}
		int64_t fsize = bf::file_size(path);
		int64_t mtime = bf::last_write_time(path);
		std::stringstream tmp;
		tmp << std::hex << fsize << "-" << std::hex << mtime;
		etag = tmp.str();
		return true;
	}
	static void thr_start(ThrBackUp *backup_info)
	{
		backup_info->Start();
		return;
	}
public:
	bool Start()
	{
		
		GetBackupInfo();//獲取備份信息
		while (1)
		{
			//對文件目錄進行監控
			BackupDirListen(CLIENT_BACKUP_DIR);
			SetBackuoInfo();
			Sleep(10);
		}
		return true;
	}
};
#endif

compress.hpp

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <unordered_map>
#include <vector>
#include <thread>
#include <boost/filesystem.hpp>
#include <boost/algorithm/string.hpp>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <zlib.h>
#include <pthread.h>
#include <sys/file.h>

//未壓縮文件存儲位置
#define UNGZIPFILE_PATH	    "www/list/"
//壓縮包存儲位置
#define GZIPFILE_PATH	    "www/zip/"
//存放文件信息（filename gzipfilename\n）
#define RECORD_FILE	    "record.list"
//熱度過期時間
#define HEAT_TIME	     2

namespace bf = boost::filesystem;

class CompressStore
{
  private:
    //用於保存文件列表
    std::unordered_map<std::string, std::string> _file_list;
    pthread_rwlock_t _rwlock;
  private:
    //1. 每次壓縮存儲線程啓動的時候，從文件中讀取列表信息
    bool GetListRecord() {
      //存儲列表信息格式如下：
      //filename gzipfilename\n
      bf::path name(RECORD_FILE);
      if(!bf::exists(name)) {
        std::cerr << "record file is not exists\n";
        return false;
      }
      std::ifstream file(RECORD_FILE, std::ios::binary);
      if(!file.is_open()){
        std::cerr << "open record file error\n";
        return false;
      }
      int64_t fsize = bf::file_size(name);
      std::string body;
      body.resize(fsize);
      file.read(&body[0], fsize);
      if(!file.good()){
        std::cerr << "record file body read error\n";
        return false;
      }
      file.close();

      std::vector<std::string> list;
      boost::split(list, body, boost::is_any_of("\n"));
      for(auto e : list) {
        //分割後的信息如下
        //filename gzipfilename
        size_t pos = e.find(" ");
        if(pos == std::string::npos) {
          continue;
        }
        std::string key = e.substr(0, pos);
        std::string val = e.substr(pos + 1);
        _file_list[key] = val;
      }
      return true;
    }
    //2. 每次壓縮存儲完畢，都要將列表信息，存儲到文件中
    bool SetListRecord() {
      std::stringstream tmp;
      for(auto i : _file_list) {
        tmp << i.first << " " << i.second << "\n";
      }
      std::ofstream file(RECORD_FILE, std::ios::binary | std::ios::trunc);
      if(!file.is_open()) {
        std::cerr << "record file open error\n";
        return false;
      }
      file.write(tmp.str().c_str(), tmp.str().size());
      if(!file.good()) {
        std::cerr << "record file write body error\n";
        return false;
      }
      file.close();
      return true;
    }
    //目錄檢測，獲取目錄中的文件名
    //  1.判斷文件是否需要壓縮存儲
    //  2.文件壓縮存儲
    bool DirectoryCheck() {
      if(!bf::exists(UNGZIPFILE_PATH)) {
        bf::create_directory(UNGZIPFILE_PATH);
      }
      std::string cmd = "bash gbk_utf8";
      FILE *fd = popen(cmd.c_str(),"r");
      pclose(fd);
      bf::directory_iterator item_begin(UNGZIPFILE_PATH);
      bf::directory_iterator item_end;

      for(; item_begin != item_end; ++item_begin) {
        if(bf::is_directory(item_begin->status())) {
          continue;
        }
        std::string name = item_begin->path().string();
        if(!IsNeedCompress(name)) {
          continue;
        }
        std::string gzip = GZIPFILE_PATH + item_begin->path().filename().string() + ".gz";
        if(CompressFile(name, gzip)) {
          std::cerr << "file:[" << name << "] store success\n";
          AddFileRecord(name, gzip);
        }else {
          std::cerr << "file:[" << name << "] store failed\n";
        }
      }
      return true;
    }
    //2.2. 判斷文件是否需要壓縮存儲
    bool IsNeedCompress(std::string &file) {
      //通過stat這個系統調用接口可以獲取文件相關信息，取最後一次訪問時間
      struct stat st;
      if(stat(file.c_str(), &st) < 0) {
        std::cerr << "get file:[" << file << "] stat error\n";
        return false;
      }
      time_t cur_time = time(nullptr);	//當前系統時間
      time_t acc_time = st.st_atime;
      if((cur_time - acc_time) < HEAT_TIME){
        return false;
      }
      return true;
    }
    //2.3. 對文件進行壓縮存儲
    bool CompressFile(std::string &file, std::string &gzip) {
      int fd = open(file.c_str(), O_RDONLY);
      if(fd < 0) {
        std::cerr << "com open file:[" << file << "] error\n";
        return false;
      }
      gzFile gf = gzopen(gzip.c_str(), "wb");
      if(gf == nullptr) {
        std::cerr << "com open gzip:[" << gzip<< "] error\n";
        return false;
      }
      int ret;
      char buf[1024];
      flock(fd, LOCK_SH);
      while((ret = read(fd, buf, 1024)) > 0) {
        gzwrite(gf, buf, ret);
      }
      flock(fd, LOCK_UN);
      close(fd);
      gzclose(gf);

      //壓縮完後，原文件就沒必要存在了，所以調用unlink刪除原文件
      //int unlink(const char *pathname);
      //如果文件正在被操作，那麼會報錯:EBUSY
      //EBUSY:The file pathname cannot be unlinked because it is being used by the system or another process; for example, it is a mount point or the NFS client software created it to represent an active but otherwise nameless inode ("NFS silly renamed").
      unlink(file.c_str());   //unlink 在刪除文件時，如果這個文件已經被打開且正在被操作，這個文件就無法刪除
      return true;
    }

    //對文件解壓縮
    bool UnCompressFile(std::string &gzip, std::string &file) {
      int fd = open(file.c_str(), O_CREAT | O_WRONLY, 0664);
      if(fd < 0) {
        std::cerr << "open file" << file << "failed\n";
        return false;
      }
      gzFile gf = gzopen(gzip.c_str(), "rb");
      if(gf == nullptr) {
        std::cerr << "open gzip " << gzip << "failed\n";
        return false;
      }
      int ret;
      char buf[1024] = {0};
      flock(fd, LOCK_EX);
      while((ret = gzread(gf, buf, 1024)) > 0) {
        int len = write(fd, buf, ret);
        if(len < 0) {
          std::cerr << "get gzip data failed\n";
          flock(fd, LOCK_UN);
          gzclose(gf);
          close(fd);
          return false;
        }
      }
      flock(fd, LOCK_UN);
      gzclose(gf);
      close(fd);
      unlink(gzip.c_str());
      return true;
    }

    bool GetNormalFile(std::string &name, std::string &body) {
      int64_t fsize = bf::file_size(name);
      body.resize(fsize);

      int fd = open(name.c_str(), O_RDONLY);
      if(fd < 0) {
        std::cerr << "open file " << name << " failed\n";
        return false;
      }

      flock(fd, LOCK_SH);
      int ret = read(fd, &body[0], fsize);
      flock(fd, LOCK_UN);
      if(ret != fsize) {
        std::cerr << "get file " << name << " body error\n";
        close(fd);
        return false;
      }
      close(fd);
      return true;
    }

  public:
    CompressStore() {
      pthread_rwlock_init(&_rwlock, nullptr);
      if(!bf::exists(GZIPFILE_PATH)) {
        bf::create_directory(GZIPFILE_PATH);
      }
    }
    ~CompressStore() {
      pthread_rwlock_destroy(&_rwlock);
    }
    //向外提供獲取文件列表功能
    bool GetFileList(std::vector<std::string> &list) {
      pthread_rwlock_rdlock(&_rwlock);
      for(auto i : _file_list) {
        list.push_back(i.first);
      }
      pthread_rwlock_unlock(&_rwlock);
      return true;
    }

    //通過文件名稱，獲取文件對應的壓縮包名稱
    bool GetFileGzip(std::string &file, std::string &gzip) {
      pthread_rwlock_rdlock(&_rwlock);
      auto it = _file_list.find(file);
      if(it == _file_list.end()){
        pthread_rwlock_unlock(&_rwlock);
        return false;
      }
      gzip = it->second;
      pthread_rwlock_unlock(&_rwlock);
      return true;
    }

    //向外提供獲取文件數據功能
    bool GetFileData(std::string &file, std::string &body) {
      if(bf::exists(file)) {
        //1. 非壓縮文件數據獲取
        GetNormalFile(file, body);
      }else{
        //2. 壓縮文件數據獲取
        //獲取壓縮文件的數據需要先將壓縮文件解壓
        std::string gzip;
        GetFileGzip(file, gzip);
        UnCompressFile(gzip, file);
        GetNormalFile(file, body);
      }
    }

    bool AddFileRecord(const std::string &file, const std::string &gzip) {
      pthread_rwlock_wrlock(&_rwlock);
      _file_list[file] = gzip; 
      pthread_rwlock_unlock(&_rwlock);
    }

    //文件存儲
    bool SetFileData(const std::string &file, const std::string &body, const int64_t offset) {
      int fd = open(file.c_str(), O_CREAT|O_WRONLY, 0664);
      if(fd < 0) {
        std::cerr << "open file " << file << "error\n";
        return false;
      }
      flock(fd, LOCK_EX);
      lseek(fd, offset, SEEK_SET);
      int ret = write(fd, &body[0], body.size());
      if(ret < 0) {
        std::cerr << "store file " << file << " data error\n";
        flock(fd, LOCK_UN);
        close(fd);
        return false;
      }
      flock(fd, LOCK_UN);
      close(fd);
      AddFileRecord(file, "");
      return true;
    }
    //因爲壓縮存儲的流程是死循環，因此需要啓動線程來完成，下面的函數就是線程入口函數
    bool LowHeatFileStore() {	//對熱度低的文件進行壓縮存儲
      //1. 獲取記錄信息
      GetListRecord();
      while(1){
        //2. 目錄檢測，文件壓縮存儲
        //2.1. 獲取list目錄下文件名稱
        //2.2. 判斷文件是否需要壓縮存儲
        //2.3. 對文件進行壓縮存儲
        DirectoryCheck();
        //3. 存儲記錄信息
        SetListRecord();
        sleep(3);
      }
    }
};
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

刪除Linux後修復Windows7啓動項

起因：裝了win7，然後在另一個分區裏裝了Ubuntu。後來格掉了Ubuntu所在的分區。系統啓動後出現命令窗口：grub rescue：_ 正確的解決方式： 1.光驅插入win7安裝盤或者用USB啓動（win7支持USB直接啓動安裝）

小昊 2020-07-03 03:35:04

DC1靶機

目標探測 因爲是在局域網內，所以使用內網掃描 目標已經確定，進行端口掃描 namp -sT -sC -p- -sV -T 3 -sT 全連接 -sC 使用默認的安全腳本 -p- 全端口 -sV 版本探測 -T 時間頻率（太快

孤君 2020-07-02 01:47:42

【完整APP】SpriteKit引擎開發iOS小遊戲之四（服務端搭建）

【服務端總體設計】 由於遊戲APP中使用了賬號與排行榜功能，所以需要部署服務器來完成數據管理以及處理網絡請求。 服務器介紹 服務器選擇的是阿里雲服務器。彈性計算服務(Elastic Compute Service, 簡稱ECS)

免于枯燥 2020-07-01 23:16:51

【完整APP】SpriteKit引擎開發iOS小遊戲之五（移動端網絡與優化）【完結】

【網絡動畫效果】 衆所周知，包括但不限於網絡處理，很多使用APP的時機都需要展示Loading或者Toast提示的形式來提升用戶的交互體驗。 自定義Loading類：是繼承UIActivityIndicatorView的子類。簡

免于枯燥 2020-07-01 23:16:51

網站項目-模仿三國殺官網

官網地址：http://www.sanguosha.com/ 提要：我是看書黨，沒有看過相關類型的視頻，在W3C學習了基礎的HTML知識，自己就開始找網站模仿，我的目標是遊戲開發，所以就模仿了一個遊戲官網。            三國殺網

安逸风声 2020-07-01 13:01:37

小項目——自制畫風數據集

承接上篇爬取了想要的數據集之後，先將圖片的尺寸統一。(我自己爬取了塗鴉，油畫，素描這3類圖片） 關於塗鴉數據集爬下來的圖片，其中混入了一些妹子和西海岸黑人黑幫文化的圖片。(爲什麼我也不知道。。。)注意清除，數據集的好壞很關鍵！ r

爱吃鱼的小刘 2020-06-30 16:36:38

小項目——馬賽克風格遷移

最近一直想做一個質量較高的塗鴉作品，但迫於非科班出生加上控瓶能力有限無法處理好圖像細節，於是用python助力藝術，將原圖畫風遷移成馬賽克風格。9行代碼，內容不多也沒什麼好講解的，用過相關庫的同志們肯定懂，就當看看塗鴉作品吧：）

爱吃鱼的小刘 2020-06-30 16:36:38

百家號爬蟲（獲取各領域創作者appid）

本文爲爬蟲及數據分析學習文章，網頁解析方法較笨，僅作紀念。 百家號爬蟲（獲取各領域創作者appid） 由於百度的限制，每個領域最多能獲取760個id #!/usr/bin/env python3 # -*- coding: utf

偲偲粑 2020-06-26 19:04:56

C#基於unity製作聊天室（TCP協議）

完成一個聊天室，首先需要有服務端，然後客戶端接入服務端，才能看到顯示的數據。 因爲有多個客戶端要接入到服務端，所以要服務端開啓多線程。 首先來搭建一個服務端，這裏我使用的是TCP協議。 這裏我新建了一個C#項目，名爲“聊天室-服務端”，其

刃龙 2020-06-26 04:17:13

unity遊戲學習製作《慕課英雄》有感

首先附上 復旦大學開設的unity遊戲製作網上視頻教程：https://www.coursera.org/lecture/unity-yinqing-youxi-kaifa/shou-ke-dan-wei-yu-jiao-shi-jie-

刃龙 2020-06-26 04:17:13

python2中下載mysql數據庫中的數據，並保存在csv文本中

本項目幾個要點： 1.數據庫中有中文，且爲unicode編碼，本項目環境爲python2 2.數據庫中時間字段爲13位的字符型的時間戳，導出時需要改成正常的時間 3.導數需求爲每一個小時導前一個小時的日誌 4.導出後，涉及到將文件

Jepson2017 2020-06-25 23:13:49

python socket實現工作站監控系統

1、需求分析 使用python實現工作站監控系統，總共分成數據採集端（客戶端）和服務器端，其中數據採集端每隔一段時間採集一份數據上傳到服務器中，並且得到服務器的反饋；服務器端則獲取客戶端採集到的數據信息，對其進行處理，然後發送反饋

魏云舒 2020-06-25 13:28:35

ffmpeg視頻解碼相關接口以及播放視頻流程解析

相關函數流程獲取音視頻具體信息: 1、avformat_alloc_context(); 負責申請一個AVFormatContext結構的內存，並進行簡單初始化 2、avformat_open_input();   打開輸入視頻文件 3、

GT19930910 2020-06-25 13:26:22

【樹莓派 有趣實踐】尋找小項目

有時候在想，有沒有一些炫酷的樹莓派小項目，在有趣實踐中成長。 於是通過不斷地尋找，找到了一些不錯的。（詳細的步驟說明、有源代碼） 目錄 一、疫情數據實時監控 二、【機械六足蜘蛛】恐怖機器人 三、LED 的炫彩發光球 四、樹莓派-人臉追蹤 

一颗小树x 2020-06-22 05:31:42

H5調用微信JSSDK開發總結

最近需要開發一個小項目，他的一個需求爲：能夠在微信中分享（轉發好友以及朋友圈），而且要求圖片和標題摘要等內容自定義。本着試一試的態度，我用手機訪問自己搭建在服務器上的IP地址，打開後映入眼簾的是這樣的（這是由於我沒有設置JS安全域名造成的

千瞱 2020-06-22 04:02:34