눈 정화용 짤방

Reference

https://github.com/tensor-programming/Rust_block_chain https://www.youtube.com/watch?v=U8GGZ4TqlQs&t=894s

main.rs

use) std::Write;

fn write(&mut self, buf: &[u8]) -> Result

• The write method will attempt to write some data into the object, returning how many bytes were successfully written.

• 완벽한 트렌잭션을 보장하지 않음. 도중 에러 시, 작업 중단이고, 버퍼의 크기 보다 같거나 작음. // Ok(n)

• ErrorKind::Interrupted

fn flush(&mut self) -> Result<()>

The flush method is useful for adapters and explicit buffers themselves for ensuring that all buffered data has been pushed out to the ‘true sink’.

use std::{fs::File, io::Write};

fn main() -> std::io::Result<()>{
    let mut buf= File::create("foo.TXT")?;
    buf.write(b" Some bytes")?;
    buf.flush()?;
    Ok(())
}

inside

    let mut miner_addr = String::new();
    let mut difficulty = String::new();
    let mut choice = String::new();

  let mut chain = blockchain::Chain::new(miner_addr.trim().to_string(), diff);

loop

match

  // 0
   process::exit(0);

blockchain.rs

https://github.com/tensor-programming/Rust_block_chain/blob/master/src/blockchain.rs

• https://namu.wiki/w/LLVM
• https://en.wikipedia.org/wiki/LLVM

Velog

• https://velog.io/@wekdnjs/LLVM

etc

• Compiler-Structure-Overview
• 로컬 환경설정이 필요 없는 웹 어셈블리 튜토리얼

• cafistrano, Fabric, puppet, chef, ansible, saltstack.com

OVF,open virtual format

VM

• vagrantup.com >> packer.io
• LXC, Docker

https://youtu.be/Kq849CpGd88

Rustlang solving cases repos Data structure Data structure2 async/sync Rc와 RefCell

Results

NEAR protocol-Smart constract

New

utilities

https://github.com/tensor-programming/Rust_Port_Sniffer

use 정리

use std::env use std::io::{self, Write}; use std::net::{IpAddr, TcpStream}; use std::str::FromStr; use std::process; use std::sync::mpsc::{Sender, channel}; use std::thread;

구문 정리

I'm usually interest in "deploy" or "develop Env".

Elastic Load Balancing

will zip) https://www.youtube.com/watch?v=VIgAT7vjol8&t=2s

auto scaling

https://docs.aws.amazon.com/autoscaling/ec2/userguide/attach-load-balancer-asg.html

Ref

1. https://aws.amazon.com/elasticloadbalancing/
2. https://aws.amazon.com/elasticloadbalancing/getting-started/?pg=ln&sec=hs
3. https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/what-is-load-balancing.html

4. https://docs.aws.amazon.com/autoscaling/ec2/userguide/autoscaling-load-balancer.html

요약

small and repeated read calls to the same file or network socket.

• when reading very large amounts at once, or reading just one or a few times. >> 별로 도움이 안된다.
• 멀티 스레딩에서 데이터 손실 위험성( BufReader::into_inner도)

use std::io::prelude::*;
use std::io::BufReader;
use std::fs::File;
fn main() -> std::io::Result<()>{
    let f= File::open("log.txt")?;
    let mut reader= BufReader::new(f);

    let mut line= String::new();
    let len= reader.read_line(&mut line)?;

    println!("First line is {} bytes long", len);
    Ok(())
}

Implementations

impl<R: Read> BufReader

pub fn new(inner: R) -> BufReader

pub fn with_capacity(capacity: usize, inner: R) -> BufReader

impl BufReader

pub fn get_ref(&self) -> &R

pub fn get_mut(&mut self) -> &mut R

pub fn buffer(&self) -> &[u8]

pub fn capacity(&self) -> usize

pub fn into_inner(self) -> R

impl<R: Seek> BufReader

pub fn seek_relative(&mut self, offset: i64) -> Result<()>

io 하위의 method들을 정리한 문서

trait.Read

Please note that each call to read() may involve a system call, and therefore, using something that implements BufRead, such as BufReader, will be more efficient.

File

use std::io;
use std::io::prelude::*;
use std::fs::File;

fn main() -> io::Result<()> {
    let mut f = File::open("foo.txt")?;
    let mut buffer = [0; 10];

    // read up to 10 bytes
    f.read(&mut buffer)?;

    let mut buffer = Vec::new();
    // read the whole file
    f.read_to_end(&mut buffer)?;

    // read into a String, so that you don't need to do the conversion.
    let mut buffer = String::new();
    f.read_to_string(&mut buffer)?;

    // and more! See the other methods for more details.
    Ok(())
}

fn read(&mut self, buf: &mut [u8]) -> Result // Required

• This function does not provide any guarantees about whether it blocks waiting for data, but if an object needs to block for a read and cannot, it will typically signal this via an Err return value.

• An error of the ErrorKind::Interrupted kind is non-fatal and the read operation should be retried if there is nothing else to do.

pub fn read_to_string<R: Read>(reader: &mut R) -> Result

https://doc.rust-lang.org/std/io/fn.read_to_string.html

(If you use Read::read_to_string you have to remember to check whether the read succeeded because otherwise your buffer will be empty or only partially full.)

• EOF 반환 하거나 위의 조건을 만족하면 String이 반환된다.(무제한으로 입력된 이유는 이러한 특성때문이다.)
• Reading 중에 오류 발생시 재사용 불가
• Safe over Performance
• Err에 String이 wrapped되어 있는 형태의 Result type 반환.

Provided methods

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<"'"_>] -> Result

fn read_to_end(&mut self, buf: &mut Vec -> Result

fn read_exact(&mut self, buf: &mut [u8] -> Result<()>

fn by_ref(&mut self) -> &mut Self

fn bytes(self) -> Bytes

fn chain<R: Read>(self, next: R) -> Chain<Self, R>

fn take(self, limit: u64) -> Take

Self: Sized

개인적으로 이 글을 읽기 위해서는 "병렬 처리 및 병렬 프로세스"에 관한 선행된 지식이 필요합니다.

https://doc.rust-lang.org/std/io/struct.Stdin.html

std::io::Stdin

'a global buffer of input data to this process'에 대한 점유를 할 수 있는 핸들러를 가리킵니다.

핸들러는 병렬처리에 의한 자원 독점('lock')을 이용하여 'BufRead methods의 전체적인 접근 권한을 얻습니다.

해당 핸들러는 'the Read trait'을 제공하지만 병렬 처리에서의 Read는 유의해서 처리해야 합니다.

pub fn lock(&self) -> StdinLock<'_>

(병렬 처리에 있어서의 자원 점유를 위한) readable 가드를 반환하는 표준 핸들러, scope에서 벗어나면 해제된다. 추가적인 구성요소로 아래의 trait들을 제공함.

• https://doc.rust-lang.org/std/io/trait.Read.html
• https://doc.rust-lang.org/std/io/trait.BufRead.html

EX

use std::io::{self, BufRead};

fn main() -> {
    let mut buffer = String::new();
    let stdin = io::stdin();
    let mut handle = stdin.lock();

    handle.read_line(&mut buffer).expect("Err: can't read");
}

pub fn read_line(&self, buf: &mut String) -> Result

• 'a line of input', appending it to the specified buffer.
• 'bytes'(the 0xA byte) or EOF
• the total number of bytes read.
• BufRead::read_line

이 메서드에서 문제가 발생하는 것 같다. 자원 공유에서의 blocking이 문제인가? 값이 제대로 할당되지 않는 문제로 계속 input이 실행된다.

// *Infinit loop* 
    io::stdin().read_to_string(&mut buf).expect("msg");

pub fn into_locked(self) -> StdinLock<"'"static>

• locking the shared global buffer associated with the stream and returning a readable guard.
• simpler to directly get a locked handle

#![feature(stdio_locked)]
  use std::io::{self, BufRead};

  fn main() -> io::Result<()>{
      let mut buffer= String::new();
    let mut handle= io::stdin().into_locked();

      handle.read_line(&mut buffer)?;
      Ok(())
  }

#![feature] may not be used on the stable release channel
코드 실행이 안된다. lock을 애용하자. // #86845

pub fn lines(self) -> Lines<StdinLock<"'"static>>

• returns an iterator

  #![feature(stdin_forwarders)]
  use std::io;

  let lines = io::stdin().lines();
  for line in lines {
      println!("got a line: {}", line.unwrap());
  }

stdin_forwarders 실행안됨. // #87096

pub fn split(self, byte: u8) -> Split<StdinLock<"'"static>>

• an iterator over input bytes // #87096

use std::io::{self, Read};

#[cfg(test)]

fn get_list() -> Vec<u8> {
    let mut buf= String::new();

    io::stdin().read_to_string(&mut buf).unwrap();

    let list= buf
        .split_whitespace()
        .map(|f| f.parse::<u8>())
        .collect::<Result<Vec<u8>, _>>()
        .unwrap();

    list
}

mod tests{
    use super::*;

    #[test]
    fn one() {
        let list= vec![10,8,6,4,2,1];

        assert_eq!(
            list
            ,get_list()
        );
    }
}

3. 무한 반복을 벗어나기 위한 방법은 두가지 존재한다.

• 데이터 셋을 설정하고, 해당 경우들만 테스트하고, 제출하지 않는다.
• 그래도 좀 더 알아보고, 구현해본다.

4. 러스트를 배우는 입장에서 정리하고 cheat sheet만들기. (String에 대한 처리도)

5. ref
   • https://hyuckkim.tistory.com/62
   • https://doc.rust-lang.org/std/io/struct.Stdin.html